YAML config files for compilers and mirrors

.gitignore

@@ -4,6 +4,7 @@
 *~
 .DS_Store
 .idea
+/etc/spack/*
 /etc/spackconfig
 /share/spack/dotkit
 /share/spack/modules

lib/spack/spack/cmd/compiler.py

@@ -68,7 +68,7 @@ def compiler_add(args):
         spack.compilers.add_compilers_to_config('user', *compilers)
         n = len(compilers)
         tty.msg("Added %d new compiler%s to %s" % (
-            n, 's' if n > 1 else '', spack.config.get_filename('user')))
+            n, 's' if n > 1 else '', spack.config.get_config_scope_filename('user', 'compilers')))
         colify(reversed(sorted(c.spec for c in compilers)), indent=4)
     else:
         tty.msg("Found no new compilers")

lib/spack/spack/cmd/config.py

@@ -43,42 +43,27 @@ def setup_parser(subparser):
 
     sp = subparser.add_subparsers(metavar='SUBCOMMAND', dest='config_command')
 
-    set_parser = sp.add_parser('set', help='Set configuration values.')
-    set_parser.add_argument('key', help="Key to set value for.")
-    set_parser.add_argument('value', nargs='?', default=None,
-                            help="Value to associate with key")
-
-    get_parser = sp.add_parser('get', help='Get configuration values.')
-    get_parser.add_argument('key', help="Key to get value for.")
+    get_parser = sp.add_parser('get', help='Print configuration values.')
+    get_parser.add_argument('category', help="Configuration category to print.")
 
     edit_parser = sp.add_parser('edit', help='Edit configuration file.')
-
-
-def config_set(args):
-    # default scope for writing is 'user'
-    if not args.scope:
-        args.scope = 'user'
-
-    config = spack.config.get_config(args.scope)
-    config.set_value(args.key, args.value)
-    config.write()
+    edit_parser.add_argument('category', help="Configuration category to edit")
 
 
 def config_get(args):
-    config = spack.config.get_config(args.scope)
-    print config.get_value(args.key)
+    spack.config.print_category(args.category)
 
 
 def config_edit(args):
     if not args.scope:
         args.scope = 'user'
-    config_file = spack.config.get_filename(args.scope)
+    if not args.category:
+        args.category = None
+    config_file = spack.config.get_config_scope_filename(args.scope, args.category)
     spack.editor(config_file)
 
 
 def config(parser, args):
-    action = { 'set'  : config_set,
-               'get'  : config_get,
+    action = { 'get' : config_get,
                'edit' : config_edit }
     action[args.config_command](args)
-

lib/spack/spack/cmd/mirror.py

@@ -75,27 +75,22 @@ def mirror_add(args):
     if url.startswith('/'):
         url = 'file://' + url
 
-    config = spack.config.get_config('user')
-    config.set_value('mirror', args.name, 'url', url)
-    config.write()
+    mirror_dict = { args.name : url }
+    spack.config.add_to_mirror_config({ args.name : url })
 
 
 def mirror_remove(args):
     """Remove a mirror by name."""
-    config = spack.config.get_config('user')
     name = args.name
 
-    if not config.has_named_section('mirror', name):
+    rmd_something = spack.config.remove_from_config('mirrors', name)
+    if not rmd_something:
         tty.die("No such mirror: %s" % name)
-    config.remove_named_section('mirror', name)
-    config.write()
 
 
 def mirror_list(args):
     """Print out available mirrors to the console."""
-    config = spack.config.get_config()
-    sec_names = config.get_section_names('mirror')
-
+    sec_names = spack.config.get_mirror_config()
     if not sec_names:
         tty.msg("No mirrors configured.")
         return
@@ -103,8 +98,7 @@ def mirror_list(args):
     max_len = max(len(s) for s in sec_names)
     fmt = "%%-%ds%%s" % (max_len + 4)
 
-    for name in sec_names:
-        val = config.get_value('mirror', name, 'url')
+    for name, val in sec_names.iteritems():
         print fmt % (name, val)
 
 

lib/spack/spack/compilers/__init__.py

@@ -60,24 +60,25 @@ def _get_config():
        first."""
     # If any configuration file has compilers, just stick with the
     # ones already configured.
-    config = spack.config.get_config()
+    config = spack.config.get_compilers_config()
     existing = [spack.spec.CompilerSpec(s)
-                for s in config.get_section_names('compiler')]
+                for s in config]
     if existing:
         return config
 
     compilers = find_compilers(*get_path('PATH'))
-    new_compilers = [
-        c for c in compilers if c.spec not in existing]
-    add_compilers_to_config('user', *new_compilers)
+    add_compilers_to_config('user', *compilers)
 
     # After writing compilers to the user config, return a full config
     # from all files.
-    return spack.config.get_config(refresh=True)
+    return spack.config.get_compilers_config()
 
 
-@memoized
+_cached_default_compiler = None
 def default_compiler():
+    global _cached_default_compiler
+    if _cached_default_compiler:
+        return _cached_default_compiler
     versions = []
     for name in _default_order:  # TODO: customize order.
         versions = find(name)
@@ -86,7 +87,8 @@ def default_compiler():
     if not versions:
         raise NoCompilersError()
 
-    return sorted(versions)[-1]
+    _cached_default_compiler = sorted(versions)[-1]
+    return _cached_default_compiler
 
 
 def find_compilers(*path):
@@ -122,19 +124,17 @@ def find_compilers(*path):
 
 
 def add_compilers_to_config(scope, *compilers):
-    config = spack.config.get_config(scope)
+    compiler_config_tree = {}
     for compiler in compilers:
-        add_compiler(config, compiler)
-    config.write()
-
-
-def add_compiler(config, compiler):
-    def setup_field(cspec, name, exe):
-        path = exe if exe else "None"
-        config.set_value('compiler', cspec, name, path)
-
+        compiler_entry = {}
         for c in _required_instance_vars:
-        setup_field(compiler.spec, c, getattr(compiler, c))
+            val = getattr(compiler, c)
+            if not val:
+                val = "None"
+            compiler_entry[c] = val
+        compiler_config_tree[str(compiler.spec)] = compiler_entry
+    spack.config.add_to_compiler_config(compiler_config_tree, scope)
+
 
 
 def supported_compilers():
@@ -157,8 +157,7 @@ def all_compilers():
        available to build with.  These are instances of CompilerSpec.
     """
     configuration = _get_config()
-    return [spack.spec.CompilerSpec(s)
-            for s in configuration.get_section_names('compiler')]
+    return [spack.spec.CompilerSpec(s) for s in configuration]
 
 
 @_auto_compiler_spec
@@ -176,7 +175,7 @@ def compilers_for_spec(compiler_spec):
     config = _get_config()
 
     def get_compiler(cspec):
-        items = dict((k,v) for k,v in config.items('compiler "%s"' % cspec))
+        items = config[str(cspec)]
 
         if not all(n in items for n in _required_instance_vars):
             raise InvalidCompilerConfigurationError(cspec)

lib/spack/spack/stage.py

@@ -344,13 +344,9 @@ def destroy(self):
 
 def _get_mirrors():
     """Get mirrors from spack configuration."""
-    config = spack.config.get_config()
+    config = spack.config.get_mirror_config()
+    return [val for name, val in config.iteritems()]
 
-    mirrors = []
-    sec_names = config.get_section_names('mirror')
-    for name in sec_names:
-        mirrors.append(config.get_value('mirror', name, 'url'))
-    return mirrors
 
 
 def ensure_access(file=spack.stage_path):

lib/spack/spack/test/config.py

@@ -26,44 +26,49 @@
 import shutil
 import os
 from tempfile import mkdtemp
+import spack
+from spack.packages import PackageDB
+from spack.test.mock_packages_test import *
 
-from spack.config import *
+class ConfigTest(MockPackagesTest):
 
+    def setUp(self):
+        self.initmock()
+        self.tmp_dir = mkdtemp('.tmp', 'spack-config-test-')
+        spack.config.config_scopes = [('test_low_priority', os.path.join(self.tmp_dir, 'low')),
+                                      ('test_high_priority', os.path.join(self.tmp_dir, 'high'))]
 
-class ConfigTest(unittest.TestCase):
+    def tearDown(self):
+        self.cleanmock()
+        shutil.rmtree(self.tmp_dir, True)
 
-    @classmethod
-    def setUp(cls):
-        cls.tmp_dir = mkdtemp('.tmp', 'spack-config-test-')
+    def check_config(self, comps):
+        config = spack.config.get_compilers_config()
+        compiler_list = ['cc', 'cxx', 'f77', 'f90']
+        for key in comps:
+            for c in compiler_list:
+                if comps[key][c] == '/bad':
+                    continue
+                self.assertEqual(comps[key][c], config[key][c])
 
 
-    @classmethod
-    def tearDown(cls):
-        shutil.rmtree(cls.tmp_dir, True)
-
-
-    def get_path(self):
-        return os.path.join(ConfigTest.tmp_dir, "spackconfig")
+    def test_write_key(self):
+        a_comps =  {"gcc@4.7.3" : { "cc" : "/gcc473", "cxx" : "/g++473", "f77" : None, "f90" : None },
+         "gcc@4.5.0" : { "cc" : "/gcc450", "cxx" : "/g++450", "f77" : "/gfortran", "f90" : "/gfortran" },
+         "clang@3.3"  : { "cc" : "/bad", "cxx" : "/bad", "f77" : "/bad", "f90" : "/bad" }}
 
+        b_comps = {"icc@10.0" : { "cc" : "/icc100", "cxx" : "/icc100", "f77" : None, "f90" : None },
+         "icc@11.1" : { "cc" : "/icc111", "cxx" : "/icp111", "f77" : "/ifort", "f90" : "/ifort" },
+         "clang@3.3" : { "cc" : "/clang", "cxx" : "/clang++", "f77" :  None, "f90" : None}}
 
-    def test_write_key(self):
-        config = SpackConfigParser(self.get_path())
-        config.set_value('compiler.cc',  'a')
-        config.set_value('compiler.cxx', 'b')
-        config.set_value('compiler', 'gcc@4.7.3', 'cc',  'c')
-        config.set_value('compiler', 'gcc@4.7.3', 'cxx', 'd')
-        config.write()
+        spack.config.add_to_compiler_config(a_comps, 'test_low_priority')
+        spack.config.add_to_compiler_config(b_comps, 'test_high_priority')
 
-        config = SpackConfigParser(self.get_path())
+        self.check_config(a_comps)
+        self.check_config(b_comps)
 
-        self.assertEqual(config.get_value('compiler.cc'),  'a')
-        self.assertEqual(config.get_value('compiler.cxx'), 'b')
-        self.assertEqual(config.get_value('compiler', 'gcc@4.7.3', 'cc'), 'c')
-        self.assertEqual(config.get_value('compiler', 'gcc@4.7.3', 'cxx'), 'd')
+        spack.config.clear_config_caches()
 
-        self.assertEqual(config.get_value('compiler', None, 'cc'),  'a')
-        self.assertEqual(config.get_value('compiler', None, 'cxx'), 'b')
-        self.assertEqual(config.get_value('compiler.gcc@4.7.3.cc'), 'c')
-        self.assertEqual(config.get_value('compiler.gcc@4.7.3.cxx'), 'd')
+        self.check_config(a_comps)
+        self.check_config(b_comps)
 
-        self.assertRaises(NoOptionError, config.get_value, 'compiler', None, 'fc')

lib/spack/spack/test/mock_packages_test.py

@@ -31,7 +31,7 @@
 
 
 def set_pkg_dep(pkg, spec):
-    """Alters dependence information for a pacakge.
+    """Alters dependence information for a package.
        Use this to mock up constraints.
     """
     spec = Spec(spec)
@@ -39,21 +39,32 @@ def set_pkg_dep(pkg, spec):
 
 
 class MockPackagesTest(unittest.TestCase):
-    def setUp(self):
+    def initmock(self):
         # Use the mock packages database for these tests.  This allows
         # us to set up contrived packages that don't interfere with
         # real ones.
         self.real_db = spack.db
         spack.db = PackageDB(spack.mock_packages_path)
 
-        self.real_scopes = spack.config._scopes
-        spack.config._scopes = {
-            'site' : spack.mock_site_config,
-            'user' : spack.mock_user_config }
+        spack.config.clear_config_caches()
+        self.real_scopes = spack.config.config_scopes
+        spack.config.config_scopes = [
+            ('site', spack.mock_site_config),
+            ('user', spack.mock_user_config)]
 
 
-    def tearDown(self):
+    def cleanmock(self):
         """Restore the real packages path after any test."""
         spack.db = self.real_db
-        spack.config._scopes = self.real_scopes
+        spack.config.config_scopes = self.real_scopes
+        spack.config.clear_config_caches()
+
+
+    def setUp(self):
+        self.initmock()
+
+
+    def tearDown(self):
+        self.cleanmock()
+
 

var/spack/mock_configs/site_spackconfig

-[compiler "gcc@4.5.0"]
-    cc  = /path/to/gcc
-    cxx = /path/to/g++
-    f77 = /path/to/gfortran
-    fc  = /path/to/gfortran
-
-[compiler "clang@3.3"]
-    cc  = /path/to/clang
-    cxx = /path/to/clang++
-    f77 = None
-    fc  = None
-

var/spack/mock_configs/site_spackconfig/compilers.yaml

+compilers:
+  all:
+    clang@3.3:
+      cc: /path/to/clang
+      cxx: /path/to/clang++
+      f77: None
+      fc: None
+    gcc@4.5.0:
+      cc: /path/to/gcc
+      cxx: /path/to/g++
+      f77: /path/to/gfortran
+      fc: /path/to/gfortran