Example #1
0
def parse_specs(args, **kwargs):
    """Convenience function for parsing arguments from specs.  Handles common
       exceptions and dies if there are errors.
    """
    concretize = kwargs.get('concretize', False)
    normalize = kwargs.get('normalize', False)
    tests = kwargs.get('tests', False)

    try:
        specs = spack.spec.parse(args)
        for spec in specs:
            if concretize:
                spec.concretize(tests=tests)  # implies normalize
            elif normalize:
                spec.normalize(tests=tests)

        return specs

    except spack.spec.SpecParseError as e:
        msg = e.message + "\n" + str(e.string) + "\n"
        msg += (e.pos + 2) * " " + "^"
        raise SpackError(msg)

    except spack.spec.SpecError as e:

        msg = e.message
        if e.long_message:
            msg += e.long_message

        raise SpackError(msg)
Example #2
0
    def test_suffixes(self, tcl_factory):
        spack.modules._module_config = self.configuration_suffix
        spec = spack.spec.Spec('mpileaks+debug arch=x86-linux')
        spec.concretize()
        generator = tcl_factory(spec)
        assert 'foo' in generator.use_name

        spec = spack.spec.Spec('mpileaks~debug arch=x86-linux')
        spec.concretize()
        generator = tcl_factory(spec)
        assert 'bar' in generator.use_name
Example #3
0
    def _impl(spec_str):
        # Write the module file
        spec = spack.spec.Spec(spec_str)
        spec.concretize()
        generator = writer_cls(spec)
        generator.write()

        # Get its filename
        filename = generator.layout.filename
        # Retrieve the content
        content = filename_dict[filename].split('\n')
        generator.remove()
        return content
Example #4
0
    def test_setup_environment(self, tcl_factory):
        spec = spack.spec.Spec('mpileaks')
        spec.concretize()
        content = get_modulefile_content(tcl_factory, spec)
        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len(
            [x for x in content if 'setenv FOOBAR "mpileaks"' in x]
        ) == 1

        content = get_modulefile_content(tcl_factory, spec['callpath'])
        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len(
            [x for x in content if 'setenv FOOBAR "callpath"' in x]
        ) == 1
Example #5
0
def get_modulefile_content(factory, spec):
    """Writes the module file and returns the content as a string.

    :param factory: module file factory
    :param spec: spec of the module file to be written
    :return: content of the module file
    :rtype: str
    """
    spec.concretize()
    generator = factory(spec)
    generator.write()
    content = FILE_REGISTRY[generator.file_name].split('\n')
    generator.remove()
    return content
Example #6
0
def create_installer(spec_name):
    """
    Create an installer for the named spec

    Args:
        spec_name (str):  Name of the explicit install spec

    Return:
        spec (Spec): concretized spec
        installer (PackageInstaller): the associated package installer
    """
    spec = spack.spec.Spec(spec_name)
    spec.concretize()
    assert spec.concrete
    return spec, inst.PackageInstaller(spec.package)
Example #7
0
def test_process_external_package_module(install_mockery, monkeypatch, capfd):
    """Test to simply cover the external module message path."""
    spec = spack.spec.Spec('trivial-install-test-package')
    spec.concretize()
    assert spec.concrete

    # Ensure take the external module path WITHOUT any changes to the database
    monkeypatch.setattr(spack.database.Database, 'get_record', _none)

    spec.external_path = '/actual/external/path/not/checked'
    spec.external_modules = ['unchecked_module']
    inst._process_external_package(spec.package, False)

    out = capfd.readouterr()[0]
    assert 'has external module in {0}'.format(spec.external_modules) in out
Example #8
0
def test_spack_monitor_send_phase(mock_monitor_request, install_mockery,
                                  install_mockery_mutable_config):

    monitor = get_client(host="hostname")

    def get_build_id(*args, **kwargs):
        return 1

    spec = spack.spec.Spec("dttop")
    spec.concretize()
    response = monitor.send_phase(spec.package, "autoconf",
                                  spec.package.install_log_path,
                                  "SUCCESS")
    assert "message" in response and "data" in response and "code" in response
    assert response['code'] == 200
Example #9
0
def test_spack_monitor_send_analyze_metadata(monkeypatch, mock_monitor_request,
                                             install_mockery,
                                             install_mockery_mutable_config):
    def buildid(*args, **kwargs):
        return 1

    monkeypatch.setattr(spack.monitor.SpackMonitorClient, "get_build_id",
                        buildid)
    monitor = get_client(host="hostname")
    spec = spack.spec.Spec("dttop")
    spec.concretize()
    response = monitor.send_analyze_metadata(spec.package,
                                             metadata={"boop": "beep"})
    assert "message" in response and "data" in response and "code" in response
    assert response['code'] == 200
Example #10
0
def test_dev_build_before(tmpdir, mock_packages, install_mockery):
    spec = spack.spec.Spec('[email protected] dev_path=%s' % tmpdir)
    spec.concretize()

    with tmpdir.as_cwd():
        with open(spec.package.filename, 'w') as f:
            f.write(spec.package.original_string)

        dev_build('-b', 'edit', '[email protected]')

        assert spec.package.filename in os.listdir(os.getcwd())
        with open(spec.package.filename, 'r') as f:
            assert f.read() == spec.package.original_string

    assert not os.path.exists(spec.prefix)
Example #11
0
def test_dev_build_basics(tmpdir, mock_packages, install_mockery):
    spec = spack.spec.Spec('[email protected] dev_path=%s' % tmpdir)
    spec.concretize()

    with tmpdir.as_cwd():
        with open(spec.package.filename, 'w') as f:
            f.write(spec.package.original_string)

        dev_build('[email protected]')

    assert spec.package.filename in os.listdir(spec.prefix)
    with open(os.path.join(spec.prefix, spec.package.filename), 'r') as f:
        assert f.read() == spec.package.replacement_string

    assert os.path.exists(str(tmpdir))
Example #12
0
def spec(parser, args):
    name_fmt = '{namespace}.{name}' if args.namespaces else '{name}'
    fmt = '{@version}{%compiler}{compiler_flags}{variants}{arch=architecture}'
    install_status_fn = spack.spec.Spec.install_status
    kwargs = {
        'cover': args.cover,
        'format': name_fmt + fmt,
        'hashlen': None if args.very_long else 7,
        'show_types': args.types,
        'status_fn': install_status_fn if args.install_status else None
    }

    # use a read transaction if we are getting install status for every
    # spec in the DAG.  This avoids repeatedly querying the DB.
    tree_context = nullcontext
    if args.install_status:
        tree_context = spack.store.db.read_transaction

    if not args.specs:
        tty.die("spack spec requires at least one spec")

    for spec in spack.cmd.parse_specs(args.specs):
        # With -y, just print YAML to output.
        if args.format:
            if spec.name in spack.repo.path or spec.virtual:
                spec.concretize()

            # The user can specify the hash type to use
            hash_type = getattr(ht, args.hash_type)

            if args.format == 'yaml':
                # use write because to_yaml already has a newline.
                sys.stdout.write(spec.to_yaml(hash=hash_type))
            else:
                print(spec.to_json(hash=hash_type))
            continue

        with tree_context():
            kwargs['hashes'] = False  # Always False for input spec
            print("Input spec")
            print("--------------------------------")
            print(spec.tree(**kwargs))

            kwargs['hashes'] = args.long or args.very_long
            print("Concretized")
            print("--------------------------------")
            spec.concretize()
            print(spec.tree(**kwargs))
Example #13
0
def get_modulefile_content(factory, spec):
    """Writes the module file and returns the content as a string.

    Args:
        factory: module file factory
        spec: spec of the module file to be written

    Returns:
        str: content of the module file
    """
    spec.concretize()
    generator = factory(spec)
    generator.write()
    content = FILE_REGISTRY[generator.file_name].split('\n')
    generator.remove()
    return content
Example #14
0
def test_build_task_basics(install_mockery):
    spec = spack.spec.Spec('dependent-install')
    spec.concretize()
    assert spec.concrete

    # Ensure key properties match expectations
    task = inst.BuildTask(spec.package, False, 0, 0, inst.STATUS_ADDED, [])
    assert task.priority == len(task.uninstalled_deps)
    assert task.key == (task.priority, task.sequence)

    # Ensure flagging installed works as expected
    assert len(task.uninstalled_deps) > 0
    assert task.dependencies == task.uninstalled_deps
    task.flag_installed(task.dependencies)
    assert len(task.uninstalled_deps) == 0
    assert task.priority == 0
Example #15
0
def test_packages_needed_to_bootstrap_compiler_packages(
        install_mockery, monkeypatch):
    spec = spack.spec.Spec('trivial-install-test-package')
    spec.concretize()

    def _conc_spec(compiler):
        return spack.spec.Spec('a').concretized()

    # Ensure we can get past functions that are precluding obtaining
    # packages.
    monkeypatch.setattr(spack.compilers, 'compilers_for_spec', _none)
    monkeypatch.setattr(spack.compilers, 'pkg_spec_for_compiler', _conc_spec)
    monkeypatch.setattr(spack.spec.Spec, 'concretize', _noop)

    packages = inst._packages_needed_to_bootstrap_compiler(spec.package)
    assert packages
Example #16
0
    def _impl(spec_str, module_set_name='default'):
        # Write the module file
        spec = spack.spec.Spec(spec_str)
        spec.concretize()
        generator = writer_cls(spec, module_set_name)
        generator.write(overwrite=True)

        # Get its filename
        filename = generator.layout.filename

        # Retrieve the content
        with open(filename) as f:
            content = f.readlines()
            content = ''.join(content).split('\n')
        generator.remove()
        return content
Example #17
0
def test_dev_build_env_dependency(tmpdir, mock_packages, install_mockery,
                                  mock_fetch, mutable_mock_env_path):
    """
    Test non-root specs in an environment are properly marked for dev builds.
    """
    # setup dev-build-test-install package for dev build
    build_dir = tmpdir.mkdir('build')
    spec = spack.spec.Spec('[email protected]')
    dep_spec = spack.spec.Spec('dev-build-test-install')

    with build_dir.as_cwd():
        dep_pkg_cls = spack.repo.path.get_pkg_class(dep_spec.name)
        with open(dep_pkg_cls.filename, 'w') as f:
            f.write(dep_pkg_cls.original_string)

    # setup environment
    envdir = tmpdir.mkdir('env')
    with envdir.as_cwd():
        with open('spack.yaml', 'w') as f:
            f.write("""\
env:
  specs:
  - [email protected]

  develop:
    dev-build-test-install:
      spec: [email protected]
      path: %s
""" % os.path.relpath(str(build_dir), start=str(envdir)))

        env('create', 'test', './spack.yaml')
        with ev.read('test'):
            # concretize in the environment to get the dev build info
            # equivalent to setting dev_build and dev_path variants
            # on all specs above
            spec.concretize()
            dep_spec.concretize()
            install()

    # Ensure that both specs installed properly
    assert dep_spec.package.filename in os.listdir(dep_spec.prefix)
    assert os.path.exists(spec.prefix)

    # Ensure variants set properly; ensure build_dir is absolute and normalized
    for dep in (dep_spec, spec['dev-build-test-install']):
        assert dep.satisfies('dev_path=%s' % build_dir)
    assert spec.satisfies('^dev_path=*')
Example #18
0
def test_dev_build_rebuild_on_source_changes(test_spec, tmpdir, mock_packages,
                                             install_mockery,
                                             mutable_mock_env_path,
                                             mock_fetch):
    """Test dev builds rebuild on changes to source code.

    ``test_spec = dev-build-test-install`` tests rebuild for changes to package
    ``test_spec = dependent-of-dev-build`` tests rebuild for changes to dep
    """
    # setup dev-build-test-install package for dev build
    build_dir = tmpdir.mkdir('build')
    spec = spack.spec.Spec('[email protected] dev_path=%s' %
                           build_dir)
    spec.concretize()

    def reset_string():
        with build_dir.as_cwd():
            with open(spec.package.filename, 'w') as f:
                f.write(spec.package.original_string)

    reset_string()

    # setup environment
    envdir = tmpdir.mkdir('env')
    with envdir.as_cwd():
        with open('spack.yaml', 'w') as f:
            f.write("""\
env:
  specs:
  - %[email protected]

  develop:
    dev-build-test-install:
      spec: [email protected]
      path: %s
""" % (test_spec, build_dir))

        env('create', 'test', './spack.yaml')
        with ev.read('test'):
            install()

            reset_string()  # so the package will accept rebuilds

            fs.touch(os.path.join(str(build_dir), 'test'))
            output = install()

    assert 'Installing %s' % test_spec in output
Example #19
0
def installer_args(spec_names, kwargs={}):
    """Return a the installer argument with each spec paired with kwargs

    Args:
        spec_names (list of str): list of spec names
        kwargs (dict or None): install arguments to apply to all of the specs

    Returns:
        list of (spec, kwargs): the installer constructor argument
    """
    arg = []
    for name in spec_names:
        spec = spack.spec.Spec(name)
        spec.concretize()
        assert spec.concrete
        arg.append((spec, kwargs))
    return arg
Example #20
0
def test_try_install_from_binary_cache(install_mockery, mock_packages,
                                       monkeypatch, capsys):
    """Tests SystemExit path for_try_install_from_binary_cache."""
    def _spec(spec, force):
        spec = spack.spec.Spec('mpi').concretized()
        return {spec: None}

    spec = spack.spec.Spec('mpich')
    spec.concretize()

    monkeypatch.setattr(spack.binary_distribution, 'get_spec', _spec)

    with pytest.raises(SystemExit):
        inst._try_install_from_binary_cache(spec.package, False, False)

    captured = capsys.readouterr()
    assert 'add a spack mirror to allow download' in str(captured)
Example #21
0
    def test_setup_environment(self, modulefile_content, module_configuration):
        """Tests the internal set-up of run-time environment."""

        module_configuration('suffix')
        content = modulefile_content('mpileaks')

        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len([x for x in content
                    if 'setenv FOOBAR "mpileaks"' in x]) == 1

        spec = spack.spec.Spec('mpileaks')
        spec.concretize()
        content = modulefile_content(str(spec['callpath']))

        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len([x for x in content
                    if 'setenv FOOBAR "callpath"' in x]) == 1
Example #22
0
 def test_no_hash(self):
     # Make sure that virtual providers (in the hierarchy) always
     # include a hash. Make sure that the module file for the spec
     # does not include a hash if hash_length is 0.
     spack.modules._module_config = self.configuration_no_hash
     spec = spack.spec.Spec(mpileaks_spec_string)
     spec.concretize()
     module = spack.modules.LmodModule(spec)
     path = module.file_name
     mpiSpec = spec['mpi']
     mpiElement = "{0}/{1}-{2}/".format(mpiSpec.name, mpiSpec.version,
                                        mpiSpec.dag_hash(length=7))
     self.assertTrue(mpiElement in path)
     mpileaksSpec = spec
     mpileaksElement = "{0}/{1}.lua".format(mpileaksSpec.name,
                                            mpileaksSpec.version)
     self.assertTrue(path.endswith(mpileaksElement))
Example #23
0
def test_build_task_errors(install_mockery):
    with pytest.raises(ValueError, match='must be a package'):
        inst.BuildTask('abc', None, False, 0, 0, 0, [])

    pkg = spack.repo.get('trivial-install-test-package')
    with pytest.raises(ValueError, match='must have a concrete spec'):
        inst.BuildTask(pkg, None, False, 0, 0, 0, [])

    spec = spack.spec.Spec('trivial-install-test-package')
    spec.concretize()
    assert spec.concrete
    with pytest.raises(ValueError, match='must have a build request'):
        inst.BuildTask(spec.package, None, False, 0, 0, 0, [])

    request = inst.BuildRequest(spec.package, {})
    with pytest.raises(inst.InstallError, match='Cannot create a build task'):
        inst.BuildTask(spec.package, request, False, 0, 0, inst.STATUS_REMOVED,
                       [])
Example #24
0
def test_install_from_cache_errors(install_mockery, capsys):
    """Test to ensure cover _install_from_cache errors."""
    spec = spack.spec.Spec('trivial-install-test-package')
    spec.concretize()
    assert spec.concrete

    # Check with cache-only
    with pytest.raises(SystemExit):
        inst._install_from_cache(spec.package, True, True, False)

    captured = str(capsys.readouterr())
    assert 'No binary' in captured
    assert 'found when cache-only specified' in captured
    assert not spec.package.installed_from_binary_cache

    # Check when don't expect to install only from binary cache
    assert not inst._install_from_cache(spec.package, False, True, False)
    assert not spec.package.installed_from_binary_cache
Example #25
0
def test_dev_build_until_last_phase(tmpdir, mock_packages, install_mockery):
    # Test that we ignore the last_phase argument if it is already last
    spec = spack.spec.Spec('[email protected] dev_path=%s' % tmpdir)
    spec.concretize()

    with tmpdir.as_cwd():
        with open(spec.package.filename, 'w') as f:
            f.write(spec.package.original_string)

        dev_build('-u', 'install', '[email protected]')

        assert spec.package.filename in os.listdir(os.getcwd())
        with open(spec.package.filename, 'r') as f:
            assert f.read() == spec.package.replacement_string

    assert os.path.exists(spec.prefix)
    assert spack.store.db.query(spec, installed=True)
    assert os.path.exists(str(tmpdir))
Example #26
0
def test_build_request_strings(install_mockery):
    """Tests of BuildRequest repr and str for coverage purposes."""
    # Using a package with one dependency
    spec = spack.spec.Spec('dependent-install')
    spec.concretize()
    assert spec.concrete

    # Ensure key properties match expectations
    request = inst.BuildRequest(spec.package, {})

    # Cover __repr__
    irep = request.__repr__()
    assert irep.startswith(request.__class__.__name__)

    # Cover __str__
    istr = str(request)
    assert "package=dependent-install" in istr
    assert "install_args=" in istr
Example #27
0
def test_packages_needed_to_bootstrap_compiler(install_mockery, monkeypatch):
    """Test to cover most of _packages_needed_to_boostrap_compiler."""

    # TODO: More work is needed to go beyond the dependency check
    def _no_compilers(pkg, arch_spec):
        return []

    # Test path where no compiler packages returned
    spec = spack.spec.Spec('trivial-install-test-package')
    spec.concretize()
    assert spec.concrete
    packages = inst._packages_needed_to_bootstrap_compiler(spec.package)
    assert not packages

    # Test up to the dependency check
    monkeypatch.setattr(spack.compilers, 'compilers_for_spec', _no_compilers)
    with pytest.raises(spack.repo.UnknownPackageError, matches='not found'):
        inst._packages_needed_to_bootstrap_compiler(spec.package)
Example #28
0
 def test_no_hash(self, lmod_factory):
     # Make sure that virtual providers (in the hierarchy) always
     # include a hash. Make sure that the module file for the spec
     # does not include a hash if hash_length is 0.
     spack.modules._module_config = self.configuration_no_hash
     spec = spack.spec.Spec(mpileaks_spec_string)
     spec.concretize()
     module = lmod_factory(spec)
     path = module.file_name
     mpi_spec = spec['mpi']
     mpiElement = "{0}/{1}-{2}/".format(
         mpi_spec.name, mpi_spec.version, mpi_spec.dag_hash(length=7)
     )
     assert mpiElement in path
     mpileaks_spec = spec
     mpileaks_element = "{0}/{1}.lua".format(
         mpileaks_spec.name, mpileaks_spec.version)
     assert path.endswith(mpileaks_element)
Example #29
0
def parse_specs(args, **kwargs):
    """Convenience function for parsing arguments from specs.  Handles common
       exceptions and dies if there are errors.
    """
    concretize = kwargs.get('concretize', False)
    normalize = kwargs.get('normalize', False)
    tests = kwargs.get('tests', False)

    try:
        sargs = args
        if not isinstance(args, six.string_types):
            if len(sargs) == 1:
                # a single argument contains a full spec and will confuse the
                # Parser if escaped -> simply take it out of the list
                if not isinstance(sargs, type([])):
                    # Since the list keyword is taken we have to get the type
                    # via the literal.
                    # Sets do not support indexing -> convert to list as simply
                    # popping the only element would modify the argument.
                    sargs = type([])(sargs)
                sargs = sargs[0]
            else:
                sargs = ' '.join(spack.util.string.quote(args))
        specs = spack.spec.parse(sargs)
        for spec in specs:
            if concretize:
                spec.concretize(tests=tests)  # implies normalize
            elif normalize:
                spec.normalize(tests=tests)

        return specs

    except spack.spec.SpecParseError as e:
        msg = e.message + "\n" + str(e.string) + "\n"
        msg += (e.pos + 2) * " " + "^"
        raise SpackError(msg)

    except spack.spec.SpecError as e:

        msg = e.message
        if e.long_message:
            msg += e.long_message

        raise SpackError(msg)
Example #30
0
def test_recursive_upstream_dbs(tmpdir_factory, test_store, gen_mock_layout):
    roots = [str(tmpdir_factory.mktemp(x)) for x in ['a', 'b', 'c']]
    layouts = [gen_mock_layout(x) for x in ['/ra/', '/rb/', '/rc/']]

    default = ('build', 'link')
    z = MockPackage('z', [], [])
    y = MockPackage('y', [z], [default])
    x = MockPackage('x', [y], [default])

    mock_repo = MockPackageMultiRepo([x, y, z])

    with spack.repo.swap(mock_repo):
        spec = spack.spec.Spec('x')
        spec.concretize()
        db_c = spack.database.Database(roots[2])
        db_c.add(spec['z'], layouts[2])

        db_b = spack.database.Database(roots[1], upstream_dbs=[db_c])
        db_b.add(spec['y'], layouts[1])

        db_a = spack.database.Database(roots[0], upstream_dbs=[db_b, db_c])
        db_a.add(spec['x'], layouts[0])

        upstream_dbs_from_scratch = (
            spack.store._construct_upstream_dbs_from_install_roots(
                [roots[1], roots[2]], _test=True))
        db_a_from_scratch = spack.database.Database(
            roots[0], upstream_dbs=upstream_dbs_from_scratch)

        assert db_a_from_scratch.db_for_spec_hash(
            spec.dag_hash()) == (db_a_from_scratch)
        assert db_a_from_scratch.db_for_spec_hash(
            spec['y'].dag_hash()) == (upstream_dbs_from_scratch[0])
        assert db_a_from_scratch.db_for_spec_hash(
            spec['z'].dag_hash()) == (upstream_dbs_from_scratch[1])

        db_a_from_scratch._check_ref_counts()
        upstream_dbs_from_scratch[0]._check_ref_counts()
        upstream_dbs_from_scratch[1]._check_ref_counts()

        assert (db_a_from_scratch.installed_relatives(spec) == set(
            spec.traverse(root=False)))
        assert (db_a_from_scratch.installed_relatives(
            spec['z'], direction='parents') == set([spec, spec['y']]))
Example #31
0
File: tcl.py Project: LLNL/spack
    def test_setup_environment(self, modulefile_content, module_configuration):
        """Tests the internal set-up of run-time environment."""

        module_configuration('suffix')
        content = modulefile_content('mpileaks')

        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len(
            [x for x in content if 'setenv FOOBAR "mpileaks"' in x]
        ) == 1

        spec = spack.spec.Spec('mpileaks')
        spec.concretize()
        content = modulefile_content(str(spec['callpath']))

        assert len([x for x in content if 'setenv FOOBAR' in x]) == 1
        assert len(
            [x for x in content if 'setenv FOOBAR "callpath"' in x]
        ) == 1
Example #32
0
def test_dev_build_before_until(tmpdir, mock_packages, install_mockery):
    spec = spack.spec.Spec('[email protected] dev_path=%s' % tmpdir)
    spec.concretize()

    with tmpdir.as_cwd():
        with open(spec.package.filename, 'w') as f:
            f.write(spec.package.original_string)

        with pytest.raises(SystemExit):
            dev_build('-u', 'edit', '-b', 'edit',
                      '[email protected]')

        with pytest.raises(SpackCommandError):
            dev_build('-u', 'phase_that_does_not_exist',
                      '[email protected]')

        with pytest.raises(SpackCommandError):
            dev_build('-b', 'phase_that_does_not_exist',
                      '[email protected]')
Example #33
0
def parse_specs(args, **kwargs):
    """Convenience function for parsing arguments from specs.  Handles common
       exceptions and dies if there are errors.
    """
    concretize = kwargs.get('concretize', False)
    normalize = kwargs.get('normalize', False)
    tests = kwargs.get('tests', False)

    sargs = args
    if not isinstance(args, six.string_types):
        sargs = ' '.join(spack.util.string.quote(args))
    specs = spack.spec.parse(sargs)
    for spec in specs:
        if concretize:
            spec.concretize(tests=tests)  # implies normalize
        elif normalize:
            spec.normalize(tests=tests)

    return specs
Example #34
0
def create_single_tarball(spec, outdir, force, relative, unsigned, allow_root,
                          signkey, rebuild_index, catch_exceptions):
    if isinstance(spec, dict):
        spec = spack.spec.Spec.from_dict(spec)
        spec.concretize()

    tty.msg('creating binary cache file for package %s ' % spec.format())
    # use return value dictionary in order to allow for additional return
    # values in the future
    retval = {"error": None}
    try:
        bindist.build_tarball(spec, outdir, force, relative, unsigned,
                              allow_root, signkey, rebuild_index)
    except spack.error.SpackError as e:
        if catch_exceptions:
            retval["error"] = "Spec %s: %s" % (spec.format(), str(e))
        else:
            # if we are not multiproccessing we can re-raise the exception
            raise e
    return retval
Example #35
0
def test_dev_build_before_until(tmpdir, mock_packages, install_mockery):
    spec = spack.spec.Spec('[email protected] dev_path=%s' % tmpdir)
    spec.concretize()

    with tmpdir.as_cwd():
        with open(spec.package.filename, 'w') as f:
            f.write(spec.package.original_string)

        with pytest.raises(SystemExit):
            dev_build('-u', 'edit', '-b', 'edit',
                      '[email protected]')

        bad_phase = 'phase_that_does_not_exist'
        not_allowed = 'is not a valid phase'
        out = dev_build('-u', bad_phase, '[email protected]')
        assert bad_phase in out
        assert not_allowed in out

        out = dev_build('-b', bad_phase, '[email protected]')
        assert bad_phase in out
        assert not_allowed in out
Example #36
0
def _concrete_spec_from_args(args):
    spec_str, specfile_path = args.spec, args.spec_file

    if not spec_str and not specfile_path:
        tty.error(
            'must provide either spec string or path to YAML or JSON specfile')
        sys.exit(1)

    if spec_str:
        try:
            constraints = spack.cmd.parse_specs(spec_str)
            spec = spack.store.find(constraints)[0]
            spec.concretize()
        except SpecError as spec_error:
            tty.error('Unable to concretize spec {0}'.format(spec_str))
            tty.debug(spec_error)
            sys.exit(1)

        return spec

    return Spec.from_specfile(specfile_path)
Example #37
0
def test_build_task_strings(install_mockery):
    """Tests of build_task repr and str for coverage purposes."""
    # Using a package with one dependency
    spec = spack.spec.Spec('dependent-install')
    spec.concretize()
    assert spec.concrete

    # Ensure key properties match expectations
    task = inst.BuildTask(spec.package, False, 0, 0, inst.STATUS_ADDED, [])

    # Cover __repr__
    irep = task.__repr__()
    assert irep.startswith(task.__class__.__name__)
    assert "status='queued'" in irep  # == STATUS_ADDED
    assert "sequence=" in irep

    # Cover __str__
    istr = str(task)
    assert "status=queued" in istr  # == STATUS_ADDED
    assert "#dependencies=1" in istr
    assert "priority=" in istr
Example #38
0
def parse_specs(args, **kwargs):
    """Convenience function for parsing arguments from specs.  Handles common
       exceptions and dies if there are errors.
    """
    concretize = kwargs.get('concretize', False)
    normalize = kwargs.get('normalize', False)

    if isinstance(args, (python_list, tuple)):
        args = " ".join(args)

    try:
        specs = spack.spec.parse(args)
        for spec in specs:
            if concretize:
                spec.concretize() # implies normalize
            elif normalize:
                spec.normalize()

        return specs

    except spack.parse.ParseError, e:
        tty.error(e.message, e.string, e.pos * " " + "^")
        sys.exit(1)
Example #39
0
 def _mock(spec_string):
     spec = spack.spec.Spec(spec_string)
     spec.concretize()
     return writer_cls(spec), spec