Exemplo n.º 1
0
def mirror_add(args):
    """Add a mirror to Spack."""
    url = args.url
    if url.startswith('/'):
        url = 'file://' + url

    mirrors = spack.config.get_config('mirrors', scope=args.scope)
    if not mirrors:
        mirrors = syaml_dict()

    for name, u in mirrors.items():
        if name == args.name:
            tty.die("Mirror with name %s already exists." % name)
        if u == url:
            tty.die("Mirror with url %s already exists." % url)
        # should only be one item per mirror dict.

    items = [(n, u) for n, u in mirrors.items()]
    items.insert(0, (args.name, url))
    mirrors = syaml_dict(items)
    spack.config.update_config('mirrors', mirrors, scope=args.scope)
def get_config(section, scope=None):
    """Get configuration settings for a section.

    If ``scope`` is ``None`` or not provided, return the merged contents
    of all of Spack's configuration scopes.  If ``scope`` is provided,
    return only the confiugration as specified in that scope.

    This off the top-level name from the YAML section.  That is, for a
    YAML config file that looks like this::

       config:
         install_tree: $spack/opt/spack
         module_roots:
           lmod:   $spack/share/spack/lmod

    ``get_config('config')`` will return::

       { 'install_tree': '$spack/opt/spack',
         'module_roots: {
             'lmod': '$spack/share/spack/lmod'
         }
       }

    """
    validate_section_name(section)
    merged_section = syaml.syaml_dict()

    if scope is None:
        scopes = config_scopes.values()
    else:
        scopes = [validate_scope(scope)]

    for scope in scopes:
        # read potentially cached data from the scope.

        data = scope.get_section(section)

        # Skip empty configs
        if not data or not isinstance(data, dict):
            continue

        if section not in data:
            tty.warn("Skipping bad configuration file: '%s'" % scope.path)
            continue

        merged_section = _merge_yaml(merged_section, data)

    # no config files -- empty config.
    if section not in merged_section:
        return {}

    # take the top key off before returning.
    return merged_section[section]
Exemplo n.º 3
0
def _generate_pkg_config(external_pkg_entries):
    """Generate config according to the packages.yaml schema for a single
    package.

    This does not generate the entire packages.yaml. For example, given some
    external entries for the CMake package, this could return::

        {
            'externals': [{
                'spec': '[email protected]',
                'prefix': '/opt/cmake-3.17.1/'
            }, {
                'spec': '[email protected]',
                'prefix': '/opt/cmake-3.16.5/'
            }]
       }
    """

    pkg_dict = syaml.syaml_dict()
    pkg_dict['externals'] = []
    for e in external_pkg_entries:
        if not _spec_is_valid(e.spec):
            continue

        external_items = [('spec', str(e.spec)), ('prefix', e.base_dir)]
        if e.spec.external_modules:
            external_items.append(('modules', e.spec.external_modules))

        if e.spec.extra_attributes:
            external_items.append(
                ('extra_attributes',
                 syaml.syaml_dict(e.spec.extra_attributes.items()))
            )

        # external_items.extend(e.spec.extra_attributes.items())
        pkg_dict['externals'].append(
            syaml.syaml_dict(external_items)
        )

    return pkg_dict
Exemplo n.º 4
0
def generate_module_index(root, modules):
    entries = syaml.syaml_dict()
    for m in modules:
        entry = {
            'path': m.layout.filename,
            'use_name': m.layout.use_name
        }
        entries[m.spec.dag_hash()] = entry
    index = {'module_index': entries}
    index_path = os.path.join(root, 'module-index.yaml')
    llnl.util.filesystem.mkdirp(root)
    with open(index_path, 'w') as index_file:
        syaml.dump(index, index_file, default_flow_style=False)
Exemplo n.º 5
0
def _generate_pkg_config(external_pkg_entries):
    """Generate config according to the packages.yaml schema for a single
    package.

    This does not generate the entire packages.yaml. For example, given some
    external entries for the CMake package, this could return::

       { 'paths': {
             '[email protected]': '/opt/cmake-3.17.1/',
             '[email protected]': '/opt/cmake-3.16.5/'
         }
       }
    """
    paths_dict = syaml.syaml_dict()
    for e in external_pkg_entries:
        if not _spec_is_valid(e.spec):
            continue
        paths_dict[str(e.spec)] = e.base_dir
    pkg_dict = syaml.syaml_dict()
    pkg_dict['paths'] = paths_dict

    return pkg_dict
Exemplo n.º 6
0
def test_ordereddict_merge_order():
    """"Test that source keys come before dest keys in merge_yaml results."""
    source = syaml.syaml_dict([
        ("k1", "v1"),
        ("k2", "v2"),
        ("k3", "v3"),
    ])

    dest = syaml.syaml_dict([
        ("k4", "v4"),
        ("k3", "WRONG"),
        ("k5", "v5"),
    ])

    result = spack.config.merge_yaml(dest, source)
    assert "WRONG" not in result.values()

    expected_keys = ["k1", "k2", "k3", "k4", "k5"]
    expected_items = [("k1", "v1"), ("k2", "v2"), ("k3", "v3"), ("k4", "v4"),
                      ("k5", "v5")]
    assert expected_keys == list(result.keys())
    assert expected_items == list(result.items())
Exemplo n.º 7
0
    def _get_config_memoized(self, section, scope):
        _validate_section_name(section)

        if scope is None:
            scopes = self.scopes.values()
        else:
            scopes = [self._validate_scope(scope)]

        merged_section = syaml.syaml_dict()
        for scope in scopes:
            # read potentially cached data from the scope.

            data = scope.get_section(section)

            # Skip empty configs
            if not data or not isinstance(data, dict):
                continue

            if section not in data:
                continue

            # We might be reading configuration files in an old format,
            # thus read data and update it in memory if need be.
            changed = _update_in_memory(data, section)
            if changed:
                self.format_updates[section].append(scope)

            merged_section = merge_yaml(merged_section, data)

        # no config files -- empty config.
        if section not in merged_section:
            return syaml.syaml_dict()

        # take the top key off before returning.
        ret = merged_section[section]
        if isinstance(ret, dict):
            ret = syaml.syaml_dict(ret)
        return ret
Exemplo n.º 8
0
def mirror_remove(args):
    """Remove a mirror by name."""
    name = args.name

    mirrors = spack.config.get_config('mirrors', scope=args.scope)
    if not mirrors:
        mirrors = syaml_dict()

    if name not in mirrors:
        tty.die("No mirror with name %s" % name)

    old_value = mirrors.pop(name)
    spack.config.update_config('mirrors', mirrors, scope=args.scope)
    tty.msg("Removed mirror %s with url %s" % (name, old_value))
Exemplo n.º 9
0
def add(name, url, scope, args={}):
    """Add a named mirror in the given scope"""
    mirrors = spack.config.get('mirrors', scope=scope)
    if not mirrors:
        mirrors = syaml_dict()

    if name in mirrors:
        tty.die("Mirror with name %s already exists." % name)

    items = [(n, u) for n, u in mirrors.items()]
    mirror_data = url
    key_values = ["s3_access_key_id", "s3_access_token", "s3_profile"]
    # On creation, assume connection data is set for both
    if any(value for value in key_values if value in args):
        url_dict = {"url": url,
                    "access_pair": (args.s3_access_key_id, args.s3_access_key_secret),
                    "access_token": args.s3_access_token,
                    "profile": args.s3_profile,
                    "endpoint_url": args.s3_endpoint_url}
        mirror_data = {"fetch": url_dict, "push": url_dict}

    items.insert(0, (name, mirror_data))
    mirrors = syaml_dict(items)
    spack.config.set('mirrors', mirrors, scope=scope)
Exemplo n.º 10
0
def _mark_overrides(data):
    if isinstance(data, list):
        return syaml.syaml_list(_mark_overrides(elt) for elt in data)

    elif isinstance(data, dict):
        marked = syaml.syaml_dict()
        for key, val in iteritems(data):
            if isinstance(key, string_types) and key.endswith(':'):
                key = syaml.syaml_str(key[:-1])
                key.override = True
            marked[key] = _mark_overrides(val)
        return marked

    else:
        return data
Exemplo n.º 11
0
    def to_dict_or_value(self):
        """Returns a dict or a value representing the current target.

        String values are used to keep backward compatibility with generic
        targets, like e.g. x86_64 or ppc64. More specific micro-architectures
        will return a dictionary which contains information on the name,
        features, vendor, generation and parents of the current target.
        """
        # Generic targets represent either an architecture
        # family (like x86_64) or a custom micro-architecture
        if self.microarchitecture.vendor == 'generic':
            return str(self)

        return syaml_dict(
            self.microarchitecture.to_dict(return_list_of_items=True))
Exemplo n.º 12
0
    def update_config(self, section, update_data, scope=None, force=False):
        """Update the configuration file for a particular scope.

        Overwrites contents of a section in a scope with update_data,
        then writes out the config file.

        update_data should have the top-level section name stripped off
        (it will be re-added).  Data itself can be a list, dict, or any
        other yaml-ish structure.

        Configuration scopes that are still written in an old schema
        format will fail to update unless ``force`` is True.

        Args:
            section (str): section of the configuration to be updated
            update_data (dict): data to be used for the update
            scope (str): scope to be updated
            force (str): force the update
        """
        if self.format_updates.get(section) and not force:
            msg = ('The "{0}" section of the configuration needs to be written'
                   ' to disk, but is currently using a deprecated format. '
                   'Please update it using:\n\n'
                   '\tspack config [--scope=<scope] update {0}\n\n'
                   'Note that previous versions of Spack will not be able to '
                   'use the updated configuration.')
            msg = msg.format(section)
            raise RuntimeError(msg)

        _validate_section_name(section)  # validate section name
        scope = self._validate_scope(scope)  # get ConfigScope object

        # manually preserve comments
        need_comment_copy = (section in scope.sections and
                             scope.sections[section] is not None)
        if need_comment_copy:
            comments = getattr(scope.sections[section][section],
                               yaml.comments.Comment.attrib,
                               None)

        # read only the requested section's data.
        scope.sections[section] = syaml.syaml_dict({section: update_data})
        if need_comment_copy and comments:
            setattr(scope.sections[section][section],
                    yaml.comments.Comment.attrib,
                    comments)

        scope._write_section(section)
Exemplo n.º 13
0
def generate_module_index(root, modules, overwrite=False):
    index_path = os.path.join(root, 'module-index.yaml')
    if overwrite or not os.path.exists(index_path):
        entries = syaml.syaml_dict()
    else:
        with open(index_path) as index_file:
            yaml_content = syaml.load(index_file)
            entries = yaml_content['module_index']

    for m in modules:
        entry = {'path': m.layout.filename, 'use_name': m.layout.use_name}
        entries[m.spec.dag_hash()] = entry
    index = {'module_index': entries}
    llnl.util.filesystem.mkdirp(root)
    with open(index_path, 'w') as index_file:
        syaml.dump(index, default_flow_style=False, stream=index_file)
Exemplo n.º 14
0
    def manifest(self):
        """The spack.yaml file that should be used in the image"""
        import jsonschema
        # Copy in the part of spack.yaml prescribed in the configuration file
        manifest = copy.deepcopy(self.config)
        manifest.pop('container')

        # Ensure that a few paths are where they need to be
        manifest.setdefault('config', syaml.syaml_dict())
        manifest['config']['install_tree'] = self.paths.store
        manifest['view'] = self.paths.view
        manifest = {'spack': manifest}

        # Validate the manifest file
        jsonschema.validate(manifest, schema=spack.schema.env.schema)

        return syaml.dump(manifest, default_flow_style=False).strip()
Exemplo n.º 15
0
def _mark_internal(data, name):
    """Add a simple name mark to raw YAML/JSON data.

    This is used by `spack config blame` to show where config lines came from.
    """
    if isinstance(data, dict):
        d = syaml.syaml_dict((_mark_internal(k, name), _mark_internal(v, name))
                             for k, v in data.items())
    elif isinstance(data, list):
        d = syaml.syaml_list(_mark_internal(e, name) for e in data)
    else:
        d = syaml.syaml_type(data)

    if syaml.markable(d):
        d._start_mark = yaml.Mark(name, None, None, None, None, None)
        d._end_mark = yaml.Mark(name, None, None, None, None, None)

    return d
Exemplo n.º 16
0
def test_view_multiple_projections(tmpdir, mock_packages, mock_archive,
                                   mock_fetch, config, install_mockery):
    install('libdwarf@20130207')
    install('[email protected]%gcc')

    viewpath = str(tmpdir.mkdir('view'))
    view_projection = s_yaml.syaml_dict([('extendee',
                                          '{name}-{compiler.name}'),
                                         ('all', '{name}-{version}')])

    projection_file = create_projection_file(tmpdir, view_projection)
    view('add', viewpath, '--projection-file={0}'.format(projection_file),
         'libdwarf', 'extendee')

    libdwarf_prefix = os.path.join(viewpath, 'libdwarf-20130207/libdwarf')
    extendee_prefix = os.path.join(viewpath, 'extendee-gcc/bin')
    assert os.path.exists(libdwarf_prefix)
    assert os.path.exists(extendee_prefix)
Exemplo n.º 17
0
def tutorial(parser, args):
    if not spack.cmd.spack_is_git_repo():
        tty.die("This command requires a git installation of Spack!")

    if not args.yes_to_all:
        tty.msg("This command will set up Spack for the tutorial at "
                "https://spack-tutorial.readthedocs.io.",
                "")
        tty.warn("This will modify your Spack configuration by:",
                 "  - deleting some configuration in ~/.spack",
                 "  - adding a mirror and trusting its public key",
                 "  - checking out a particular branch of Spack",
                 "")
        if not tty.get_yes_or_no("Are you sure you want to proceed?"):
            tty.die("Aborted")

    rm_cmds = ["rm -f %s" % f for f in rm_configs]
    tty.msg("Reverting compiler and repository configuration", *rm_cmds)
    for path in rm_configs:
        if os.path.exists(path):
            shutil.rmtree(path, ignore_errors=True)

    tty.msg("Ensuring that the tutorial binary mirror is configured:",
            "spack mirror add tutorial %s" % tutorial_mirror)
    mirror_config = syaml_dict()
    mirror_config["tutorial"] = tutorial_mirror
    spack.config.set('mirrors', mirror_config, scope="user")

    tty.msg("Ensuring that we trust tutorial binaries",
            "spack gpg trust %s" % tutorial_key)
    spack.util.gpg.trust(tutorial_key)

    # Note that checkout MUST be last. It changes Spack under our feet.
    # If you don't put this last, you'll get import errors for the code
    # that follows (exacerbated by the various lazy singletons we use)
    tty.msg("Ensuring we're on the releases/v{0}.{1} branch".format(
        *spack.spack_version_info[:2]
    ))
    git = which("git", required=True)
    with working_dir(spack.paths.prefix):
        git("checkout", tutorial_branch)
Exemplo n.º 18
0
    def write_includes(self, path):
        abspath = os.path.abspath(path)
        sections = list(spack.config.section_schemas.keys())
        data = syaml.syaml_dict()
        try:
            for s in sections:
                # we have to check that there is data in each scope
                # or else ill-formatted output can occur
                has_data = False
                for scope in self.config.scopes.values():
                    if scope.get_section(s) is not None:
                        has_data = True
                if(has_data):
                    temp = self.config.get_config(s)
                    data[s] = temp
        except (yaml.YAMLError, IOError):
            raise spack.config.ConfigError("Error reading configuration: %s" % s)

        with open(abspath, 'w') as fout:
            syaml.dump_config(data,
                              stream=fout, default_flow_style=False, blame=False)
Exemplo n.º 19
0
    def set(self, path, value, scope=None):
        """Convenience function for setting single values in config files.

        Accepts the path syntax described in ``get()``.
        """
        if ':' not in path:
            # handle bare section name as path
            self.update_config(path, value, scope=scope)
            return

        parts = process_config_path(path)
        section = parts.pop(0)

        section_data = self.get_config(section, scope=scope)

        data = section_data
        while len(parts) > 1:
            key = parts.pop(0)

            if _override(key):
                new = type(data[key])()
                del data[key]
            else:
                new = data[key]

            if isinstance(new, dict):
                # Make it an ordered dict
                new = syaml.syaml_dict(new)
                # reattach to parent object
                data[key] = new
            data = new

        if _override(parts[0]):
            data.pop(parts[0], None)

        # update new value
        data[parts[0]] = value

        self.update_config(section, section_data, scope=scope)
Exemplo n.º 20
0
def test_compiler_config_modifications(monkeypatch):
    s = spack.spec.Spec('cmake')
    s.concretize()
    pkg = s.package

    os.environ['SOME_VAR_STR'] = ''
    os.environ['SOME_VAR_NUM'] = '0'
    os.environ['PATH_LIST'] = '/path/third:/path/forth'
    os.environ['EMPTY_PATH_LIST'] = ''
    os.environ.pop('NEW_PATH_LIST', None)

    env_mod = syaml_dict()
    set_cmd = syaml_dict()
    env_mod[syaml_str('set')] = set_cmd

    set_cmd[syaml_str('SOME_VAR_STR')] = syaml_str('SOME_STR')
    set_cmd[syaml_str('SOME_VAR_NUM')] = 1

    monkeypatch.setattr(pkg.compiler, 'environment', env_mod)
    spack.build_environment.setup_package(pkg, False)
    assert os.environ['SOME_VAR_STR'] == 'SOME_STR'
    assert os.environ['SOME_VAR_NUM'] == str(1)

    env_mod = syaml_dict()
    unset_cmd = syaml_dict()
    env_mod[syaml_str('unset')] = unset_cmd

    unset_cmd[syaml_str('SOME_VAR_STR')] = None

    monkeypatch.setattr(pkg.compiler, 'environment', env_mod)
    assert 'SOME_VAR_STR' in os.environ
    spack.build_environment.setup_package(pkg, False)
    assert 'SOME_VAR_STR' not in os.environ

    env_mod = syaml_dict()
    set_cmd = syaml_dict()
    env_mod[syaml_str('set')] = set_cmd
    append_cmd = syaml_dict()
    env_mod[syaml_str('append-path')] = append_cmd
    unset_cmd = syaml_dict()
    env_mod[syaml_str('unset')] = unset_cmd
    prepend_cmd = syaml_dict()
    env_mod[syaml_str('prepend-path')] = prepend_cmd

    set_cmd[syaml_str('EMPTY_PATH_LIST')] = syaml_str('/path/middle')

    append_cmd[syaml_str('PATH_LIST')] = syaml_str('/path/last')
    append_cmd[syaml_str('EMPTY_PATH_LIST')] = syaml_str('/path/last')
    append_cmd[syaml_str('NEW_PATH_LIST')] = syaml_str('/path/last')

    unset_cmd[syaml_str('SOME_VAR_NUM')] = None

    prepend_cmd[syaml_str('PATH_LIST')] = syaml_str('/path/first:/path/second')
    prepend_cmd[syaml_str('EMPTY_PATH_LIST')] = syaml_str('/path/first')
    prepend_cmd[syaml_str('NEW_PATH_LIST')] = syaml_str('/path/first')
    prepend_cmd[syaml_str('SOME_VAR_NUM')] = syaml_str('/8')

    assert 'SOME_VAR_NUM' in os.environ
    monkeypatch.setattr(pkg.compiler, 'environment', env_mod)
    spack.build_environment.setup_package(pkg, False)
    # Check that the order of modifications is respected and the
    # variable was unset before it was prepended.
    assert os.environ['SOME_VAR_NUM'] == '/8'

    expected = '/path/first:/path/second:/path/third:/path/forth:/path/last'
    assert os.environ['PATH_LIST'] == expected

    expected = '/path/first:/path/middle:/path/last'
    assert os.environ['EMPTY_PATH_LIST'] == expected

    expected = '/path/first:/path/last'
    assert os.environ['NEW_PATH_LIST'] == expected

    os.environ.pop('SOME_VAR_STR', None)
    os.environ.pop('SOME_VAR_NUM', None)
    os.environ.pop('PATH_LIST', None)
    os.environ.pop('EMPTY_PATH_LIST', None)
    os.environ.pop('NEW_PATH_LIST', None)
Exemplo n.º 21
0
def add_pr_mirror(url):
    cfg_scope = cfg.default_modify_scope()
    mirrors = cfg.get('mirrors', scope=cfg_scope)
    items = [(n, u) for n, u in mirrors.items()]
    items.insert(0, ('ci_pr_mirror', url))
    cfg.set('mirrors', syaml.syaml_dict(items), scope=cfg_scope)
Exemplo n.º 22
0
 def clear(self):
     """Empty cached config information."""
     self.sections = syaml.syaml_dict()
Exemplo n.º 23
0
 def to_dict(self):
     return syaml_dict([('name', self.name), ('version', self.version)])
Exemplo n.º 24
0
 def __init__(self, name, path):
     self.name = name           # scope name.
     self.path = path           # path to directory containing configs.
     self.sections = syaml.syaml_dict()  # sections read from config files.
Exemplo n.º 25
0
 def to_dict(self):
     return syaml_dict(
         (('platform', str(self.platform) if self.platform else None),
          ('platform_os',
           str(self.platform_os) if self.platform_os else None),
          ('target', str(self.target) if self.target else None)))
Exemplo n.º 26
0
 def to_dict(self):
     if self._push_url is None:
         return self._fetch_url
     else:
         return syaml_dict([('fetch', self._fetch_url),
                            ('push', self._push_url)])
Exemplo n.º 27
0
 def to_dict(self, recursive=False):
     return syaml_dict(
         sorted(((k, (v.to_dict() if recursive else v))
                 for (k, v) in self._mirrors.items()),
                key=operator.itemgetter(0)))
Exemplo n.º 28
0
def export(parser, args):
    q_args = {"explicit": True if args.explicit else any}
    specs = args.specs(**q_args)

    # Exit early if no package matches the constraint
    if not args.specs and args.constraint:
        msg = "No package matches the query: {0}"
        msg = msg.format(' '.join(args.constraint))
        tty.msg(msg)
        return

    packages = spack.config.get('packages', scope=args.scope)

    # If tags have been specified on the command line, filter by tags
    if args.tags:
        packages_with_tags = spack.repo.path.packages_with_tags(*args.tags)
        specs = [x for x in specs if x.name in packages_with_tags]

    if args.exclude:
        specs = set(filter_exclude(specs, args.exclude))

    cls = None
    if args.module:
        cls = spack.modules.module_types[args.module]

    # Collect packages per package name
    pkgs = {}
    for spec in specs:
        pkgs.setdefault(spec.name, []).append(spec)

    pymods = {}

    # Dump per package, make sure that none are forgotten
    for pkg, pkg_specs in pkgs.items():
        paths = syaml_dict()
        modules = syaml_dict()
        package = packages.setdefault(pkg, syaml_dict())
        versions = None
        if 'version' in package:
            versions = [str(v) for v in package['version']]

        for spec in pkg_specs:
            key = spec.format(args.format)
            sflags = []
            bflags = []
            for k, v in spec.variants.items():
                default = None
                if k in spec.package.variants:
                    default = spec.package.variants[k].default
                if v.value != default or args.variants == 'all':
                    if v.value in (True, False):
                        bflags.append(v)
                    elif v.name != 'patches':
                        sflags.append(v)

            sflags = ' '.join(str(f) for f in sorted(sflags))
            bflags = ''.join(str(f) for f in sorted(bflags))
            key = ' '.join([e for e in (key, sflags, bflags) if len(e) > 0])
            key = str(key)

            if isinstance(spec.package, PythonPackage):
                py = spec['python']
                if args.dependencies:
                    key += " ^{0}".format(py.format("$_$@"))

                if not spec.package.is_activated(py.package.view()):
                    # For external packages, setup_environment is not
                    # called, and thus they are not included in
                    # PYTHON_PATH.
                    msg = "python package not activated, skipping: {0}"
                    msg = msg.format(spec.format("$_$@"))
                    tty.warn(msg)
                    # paths[key] = str(spec.prefix)
                else:
                    mod = pymods.setdefault(py, cls(py) if cls else None)
                    if mod and not mod.conf.blacklisted:
                        if os.path.exists(mod.layout.filename):
                            paths[key] = '/activated'
                            # modules[key] = mod.layout.use_name
                            # paths[key] = str(spec.prefix)
                    else:
                        msg = "python package activated in inactive module, skipping: {0}"
                        msg = msg.format(spec.format("$_$@"))
                        tty.warn(msg)
                        continue
            else:
                mod = cls(spec) if cls else None
                if mod and not mod.conf.blacklisted:
                    if os.path.exists(mod.layout.filename):
                        modules[key] = str(mod.layout.use_name)
                    else:
                        msg = "module not present for {0}"
                        msg = msg.format(spec.format("$_$@"))
                        tty.warn(msg)
                # Even with modules, the path needs to be present to, e.g.,
                # have `spack setup` work!
                paths.setdefault(key, []).append(spec)

            if versions and str(spec.version) not in versions:
                versions.append(str(spec.version))

        if versions:
            package['version'] = syaml_list(sorted(versions, reverse=True))
        if len(paths) > 0:

            def install_date(s):
                _, record = spack.store.db.query_by_spec_hash(s.dag_hash())
                return record.installation_time

            for k in paths.keys():
                values = paths[k]
                if values == '/activated':
                    continue
                paths[k] = str(
                    sorted(values, key=install_date, reverse=True)[0].prefix)
            package.setdefault('paths', syaml_dict()).update(paths)
        if len(modules) > 0:
            package.setdefault('modules', syaml_dict()).update(modules)

    # Trim empty items from the yaml
    for cfg in packages.values():
        for k, v in list(cfg.items()):
            if (k == 'buildable' and v) or (hasattr(v, '__iter__')
                                            and len(v) == 0):
                del cfg[k]

    # Restore ordering
    packages = syaml_dict(
        sorted((k, v) for (k, v) in packages.items() if len(v) > 0))
    if 'all' in packages:
        packages['all'] = packages.pop('all')
    yaml.dump({'packages': packages},
              stream=sys.stdout,
              default_flow_style=False,
              Dumper=PackagesDumper)
Exemplo n.º 29
0
 def to_dict(self):
     str_or_none = lambda v: str(v) if v else None
     d = syaml_dict([('platform', str_or_none(self.platform)),
                     ('platform_os', str_or_none(self.os)),
                     ('target', self.target.to_dict_or_value())])
     return syaml_dict([('arch', d)])
Exemplo n.º 30
0
 def to_dict(self):
     """Generate human-readable dict for YAML."""
     if self.concrete:
         return syaml_dict([('version', str(self[0]))])
     else:
         return syaml_dict([('versions', [str(v) for v in self])])