Merge lp:~ubuntudotcom1/maas/kill-all-the-configs-cluster into lp:~maas-committers/maas/trunk

[ubuntudotcom1]

Config changes applied according to new config backend in -cluster-admin. branch.

Config changes applied according to new config backend in -cluster-admin. branch.

[Gavin Panella (allenap)]

There's a minor conflict in src/provisioningserver/plugin.py.

[Gavin Panella (allenap)]

Looks good. I have a few comments, but they're not blockers.

I am interested in what your plan is for upgrading from pserv.yaml. Is that entirely happening in packaging?

review: Approve

[Gavin Panella (allenap)]

This has been superseded by lp:~allenap/maas/kill-all-the-configs-cluster (which builds on this).

=== modified file '.gitignore'
--- .gitignore	2015-04-10 09:45:46 +0000
+++ .gitignore	2015-05-04 14:27:25 +0000
@@ -22,6 +22,8 @@
 /docs/_autosummary
 /docs/_build
 /docs/api.rst
+/etc/maas/regiond.conf
+/etc/maas/clusterd.conf
 /eggs
 /include
 /lib
 
=== removed file 'etc/demo_maas_cluster.conf'
--- etc/demo_maas_cluster.conf	2015-03-12 18:13:14 +0000
+++ etc/demo_maas_cluster.conf	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-# This is the version of maas_cluster.conf that's used when running from a
-# branch.  The region controller will serve HTTP on a different port from a
-# packaged MAAS, and the master cluster controller (running on the same
-# development machine) has a fixed UUID.
-# It is also carefully crafted so it works as both a bash script and a
-# Python script.
-MAAS_URL="http://0.0.0.0:5240/MAAS/"
-CLUSTER_UUID="adfd3977-f251-4f2c-8d61-745dbd690bf2"
 
=== removed file 'etc/maas/pserv.yaml'
--- etc/maas/pserv.yaml	2015-04-24 13:27:39 +0000
+++ etc/maas/pserv.yaml	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-##
-## Provisioning Server (pserv) configuration.
-##
-
-## Where to log. This log can be rotated by sending SIGUSR1 to the
-## running server.
-#
-# logfile: "pserv.log"
-logfile: "/dev/null"
-
-## TFTP configuration.
-#
-tftp:
-  # The "root" setting has been replaced by "resource_root".  The old setting
-  # is used one final time when upgrading a pre-14.04 cluster controller to a
-  # 14.04 version.  After that upgrade, it can be removed.
-  #
-  # resource_root: /var/lib/maas/boot-resources/current/
-
-  # port: 69
-  port: 5244
-  ## The URL to be contacted to generate PXE configurations.
-  # generator: http://localhost/MAAS/api/1.0/pxeconfig/
-  generator: http://localhost:5240/MAAS/api/1.0/pxeconfig/
 
=== removed file 'etc/maas_cluster.conf'
--- etc/maas_cluster.conf	2015-03-12 18:13:14 +0000
+++ etc/maas_cluster.conf	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-# This file is used by the cluster controller startup script:
-# `maas-provision start-cluster-controller`
-# to get the URL to the MAAS region controller's API. Normally, packaging
-# will update this file automatically but it may also be configured manually.
-MAAS_URL=http://localhost/MAAS
 
=== modified file 'services/clusterd/run'
--- services/clusterd/run	2015-04-10 09:45:46 +0000
+++ services/clusterd/run	2015-05-04 14:27:25 +0000
@@ -21,11 +21,6 @@
 script="$(readlink -f bin/twistd.cluster)"
 config="$(readlink -f etc/maas/pserv.yaml)"
 
-# Obtain the development setting for CLUSTER_UUID.
-. etc/demo_maas_cluster.conf
-export CLUSTER_UUID
-export MAAS_URL
-
 exec $(command -v authbind && echo --deep) \
     "${script}" --nodaemon --pidfile="" maas-clusterd \
     --introspect="unix:${here}/introspect:lockfile=0" \
 
=== modified file 'setup.py'
--- setup.py	2015-05-04 14:27:25 +0000
+++ setup.py	2015-05-04 14:27:25 +0000
@@ -64,9 +64,7 @@
 
     data_files=[
         ('/etc/maas',
-            ['etc/maas/pserv.yaml',
-             'etc/maas/drivers.yaml',
-             'etc/maas_cluster.conf',
+            ['etc/maas/drivers.yaml',
              'contrib/maas-http.conf']),
         ('/etc/maas/templates/uefi',
             glob('etc/maas/templates/uefi/*.template')),
 
=== modified file 'src/maasserver/clusterrpc/tests/test_boot_images.py'
--- src/maasserver/clusterrpc/tests/test_boot_images.py	2015-03-25 15:33:23 +0000
+++ src/maasserver/clusterrpc/tests/test_boot_images.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -37,6 +37,10 @@
     compose_image_path,
     locate_tftp_path,
 )
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
 from provisioningserver.rpc import (
     boot_images,
     clusterservice,
@@ -45,6 +49,7 @@
     make_boot_image_storage_params,
     make_image,
 )
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from twisted.internet.defer import succeed
 
 
@@ -141,11 +146,14 @@
 
     def setUp(self):
         super(TestGetBootImages, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         resource_dir = self.make_dir()
         self.tftproot = os.path.join(resource_dir, 'current')
         os.mkdir(self.tftproot)
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
-        self.patch(boot_images, 'BOOT_RESOURCES_STORAGE', resource_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            self.tftproot)
 
     def test_returns_boot_images(self):
         nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ACCEPTED)
@@ -170,11 +178,14 @@
 
     def setUp(self):
         super(TestGetAvailableBootImages, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         resource_dir = self.make_dir()
         self.tftproot = os.path.join(resource_dir, 'current')
         os.mkdir(self.tftproot)
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
-        self.patch(boot_images, 'BOOT_RESOURCES_STORAGE', resource_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            self.tftproot)
 
     def test_returns_boot_images_for_one_cluster(self):
         factory.make_NodeGroup().accept()
@@ -260,11 +271,14 @@
 
     def setUp(self):
         super(TestGetBootImagesFor, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         resource_dir = self.make_dir()
         self.tftproot = os.path.join(resource_dir, 'current')
         os.mkdir(self.tftproot)
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
-        self.patch(boot_images, 'BOOT_RESOURCES_STORAGE', resource_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            self.tftproot)
 
     def make_boot_images(self):
         purposes = ['install', 'commissioning', 'xinstall']
@@ -279,7 +293,7 @@
         return [
             make_image(param, purpose)
             for purpose in purposes
-            ]
+        ]
 
     def test_returns_boot_images_matching_subarchitecture(self):
         nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ACCEPTED)
 
=== modified file 'src/provisioningserver/__main__.py'
--- src/provisioningserver/__main__.py	2015-03-30 18:05:57 +0000
+++ src/provisioningserver/__main__.py	2015-05-04 14:27:25 +0000
@@ -14,6 +14,7 @@
 
 __metaclass__ = type
 
+
 from provisioningserver import security
 import provisioningserver.boot.install_bootloader
 import provisioningserver.boot.install_grub
@@ -42,6 +43,8 @@
 
 
 main = MainScript(__doc__)
+
+
 for name, command in sorted(script_commands.items()):
     main.register(name, command)
 main()
 
=== modified file 'src/provisioningserver/boot/install_grub.py'
--- src/provisioningserver/boot/install_grub.py	2015-02-24 20:11:09 +0000
+++ src/provisioningserver/boot/install_grub.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -15,12 +15,15 @@
 __all__ = [
     "add_arguments",
     "run",
-    ]
+]
 
 import os.path
 
 from provisioningserver.boot.install_bootloader import make_destination
-from provisioningserver.config import Config
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.utils.fs import write_text_file
 
 
@@ -44,7 +47,7 @@
     """Install a GRUB2 pre-boot loader config into the TFTP
     directory structure.
     """
-    config = Config.load(args.config_file)
-    grubroot = os.path.join(config["tftp"]["resource_root"], 'grub')
+    grubroot = os.path.join(get_config_cluster_variable(
+        CLUSTER_CONFIG.DB_tftp_resource_root), 'grub')
     destination_path = make_destination(grubroot)
     write_text_file(os.path.join(destination_path, 'grub.cfg'), CONFIG_FILE)
 
=== modified file 'src/provisioningserver/boot/tests/test_install_grub.py'
--- src/provisioningserver/boot/tests/test_install_grub.py	2014-08-13 21:49:35 +0000
+++ src/provisioningserver/boot/tests/test_install_grub.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -20,7 +20,11 @@
 from maastesting.testcase import MAASTestCase
 import provisioningserver.boot.install_grub
 from provisioningserver.boot.tftppath import locate_tftp_path
-from provisioningserver.testing.config import set_tftp_root
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.utils.script import MainScript
 from testtools.matchers import FileExists
 
@@ -28,14 +32,17 @@
 class TestInstallGrub(MAASTestCase):
 
     def test_integration(self):
+        self.useFixture(ClusterConfigurationFixture())
         tftproot = self.make_dir()
-        config_fixture = self.useFixture(set_tftp_root(tftproot))
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_tftp_resource_root,
+            tftproot)
 
         action = factory.make_name("action")
         script = MainScript(action)
         script.register(action, provisioningserver.boot.install_grub)
         script.execute(
-            ("--config-file", config_fixture.filename, action))
+            ("--config-file", "clusterd.conf", action))
 
         config_filename = os.path.join('grub', 'grub.cfg')
         self.assertThat(
 
=== modified file 'src/provisioningserver/boot/tests/test_tftppath.py'
--- src/provisioningserver/boot/tests/test_tftppath.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/boot/tests/test_tftppath.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -21,7 +21,6 @@
 from maastesting.matchers import MockCalledOnceWith
 from maastesting.testcase import MAASTestCase
 from mock import Mock
-from provisioningserver import config
 from provisioningserver.boot import tftppath
 from provisioningserver.boot.tftppath import (
     compose_image_path,
@@ -35,6 +34,10 @@
     locate_tftp_path,
     maas_meta_last_modified,
 )
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.drivers.osystem import OperatingSystemRegistry
 from provisioningserver.import_images.boot_image_mapping import (
     BootImageMapping,
@@ -48,7 +51,10 @@
     make_boot_image_storage_params,
     make_image,
 )
-from provisioningserver.testing.config import set_tftp_root
+from provisioningserver.testing.config import (
+    ClusterConfigurationFixture,
+    set_tftp_root,
+)
 from provisioningserver.testing.os import make_osystem
 from testtools.matchers import (
     Not,
@@ -102,12 +108,13 @@
         self.assertIsNone(observed)
 
     def test_maas_meta_last_modified_defaults_tftproot(self):
+        self.useFixture(ClusterConfigurationFixture())
         path = factory.make_file(self.tftproot, name="maas.meta")
         maas_meta_file_path = self.patch(tftppath, 'maas_meta_file_path')
         maas_meta_file_path.return_value = path
         maas_meta_last_modified()
-        expected_path = os.path.join(
-            config.BOOT_RESOURCES_STORAGE, 'current')
+        expected_path = get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_tftp_resource_root)
         self.assertThat(maas_meta_file_path, MockCalledOnceWith(expected_path))
 
     def test_maas_meta_last_modified_reraises_non_ENOENT(self):
@@ -299,7 +306,7 @@
         resource = dict(
             subarches=factory.make_name("subarch"),
             other_item=factory.make_name("other"),
-            )
+        )
         image = make_image_spec()
         mapping = set_resource(image_spec=image, resource=resource)
         metadata = mapping.dump_json()
@@ -313,7 +320,7 @@
             "subarchitecture": image.subarch,
             "release": image.release,
             "label": image.label,
-            }
+        }
         extracted_data = extract_metadata(metadata, params)
 
         # We only expect the supported_subarches key from the resource data.
@@ -323,7 +330,7 @@
     def test_extract_metadata_handles_missing_subarch(self):
         resource = dict(
             other_item=factory.make_name("other"),
-            )
+        )
         image = make_image_spec()
         mapping = set_resource(image_spec=image, resource=resource)
         metadata = mapping.dump_json()
@@ -337,7 +344,7 @@
             "subarchitecture": image.subarch,
             "release": image.release,
             "label": image.label,
-            }
+        }
         self.assertEqual({}, extract_metadata(metadata, params))
 
     def _make_path(self):
 
=== modified file 'src/provisioningserver/boot/tftppath.py'
--- src/provisioningserver/boot/tftppath.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/boot/tftppath.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -17,13 +17,16 @@
     'list_boot_images',
     'list_subdirs',
     'locate_tftp_path',
-    ]
+]
 
 import errno
 from itertools import chain
 import os.path
 
-from provisioningserver import config
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.drivers.osystem import (
     BOOT_IMAGE_PURPOSE,
     OperatingSystemRegistry,
@@ -137,7 +140,7 @@
         subarch=params["subarchitecture"],
         release=params["release"],
         label=params["label"],
-        )
+    )
     try:
         # On upgrade from 1.5 to 1.6, the subarches does not exist in the
         # maas.meta file . Without this catch boot images will fail to
@@ -206,10 +209,12 @@
     or None if the file doesn't exist.
 
     :param tftproot: Optional tftp root dir, defaults to
-        provisioningserver.config.BOOT_RESOURCES_STORAGE
+        'tftp-root' in the cluster Config backend. Please refer to the
+        'maas-provision config --tftp-root' command to set this directory
     """
     if tftproot is None:
-        tftproot = os.path.join(config.BOOT_RESOURCES_STORAGE, 'current')
+        tftproot = get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_tftp_resource_root)
     meta_file = maas_meta_file_path(tftproot)
     try:
         return os.path.getmtime(meta_file)
 
=== modified file 'src/provisioningserver/cluster_config.py'
--- src/provisioningserver/cluster_config.py	2015-04-02 18:44:12 +0000
+++ src/provisioningserver/cluster_config.py	2015-05-04 14:27:25 +0000
@@ -13,13 +13,10 @@
 
 __metaclass__ = type
 __all__ = [
-    'get_cluster_uuid',
-    'get_maas_url',
-    "get_cluster_variable",
     "get_config_cluster_variable",
-    "set_config_cluster_variable", ]
-
-from os import environ
+    "get_tftp_generator",
+    "set_config_cluster_variable",
+    "CLUSTER_CONFIG", ]
 
 from provisioningserver.config import ClusterConfiguration
 
@@ -34,7 +31,7 @@
     DB_tftpport = 'tftp_port'
 
 
-# New get function for ClusterConfiguration backend
+# Get function for ClusterConfiguration backend
 def get_config_cluster_variable(var):
     """Obtain the given environment variable from clusterd config"""
     with ClusterConfiguration.open() as config:
@@ -52,37 +49,6 @@
     """Return the `tftp_generator` setting, which is
        <maas url>/api/1.0/pxeconfig/
     """
-    return '/'.join(get_cluster_variable(CLUSTER_CONFIG.DB_maas_url),
-                    'api', '1.0', 'pxeconfig')
-
-
-# Old get function for config file (via env variables) backend,
-# to be removed in follow-up branch. This branch is a prerequisite branch for
-# a follow-up branch, where this function will be removed. Both
-# the new and old versions of this function have been included
-# in this intermediate branch at the request of the package
-# maintainers.
-def get_cluster_variable(var):
-    """Obtain the given environment variable from maas_cluster.conf.
-
-    If the variable is not set, it probably means that whatever script
-    started the current process neglected to run maas_cluster.conf.
-    In that case, fail helpfully but utterly.
-    """
-    value = environ.get(var)
-    if value is None:
-        raise AssertionError(
-            "%s is not set.  This probably means that the script which "
-            "started this program failed to source maas_cluster.conf."
-            % var)
-    return value
-
-
-def get_cluster_uuid():
-    """Return the `CLUSTER_UUID` setting."""
-    return get_cluster_variable('CLUSTER_UUID')
-
-
-def get_maas_url():
-    """Return the `MAAS_URL` setting."""
-    return get_cluster_variable('MAAS_URL')
+    return '/'.join((
+        get_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url),
+        'api', '1.0', 'pxeconfig'))
 
=== modified file 'src/provisioningserver/config.py'
--- src/provisioningserver/config.py	2015-04-04 00:40:18 +0000
+++ src/provisioningserver/config.py	2015-05-04 14:27:25 +0000
@@ -52,7 +52,6 @@
 
 __metaclass__ = type
 __all__ = [
-    "BOOT_RESOURCES_STORAGE",
     "BootSources",
     "Config",
     "ConfigBase",
@@ -100,11 +99,6 @@
 )
 import yaml
 
-# Path to the directory on the cluster controller where boot resources are
-# stored.  This used to be configurable in bootresources.yaml, and may become
-# configurable again in the future.
-BOOT_RESOURCES_STORAGE = '/var/lib/maas/boot-resources/'
-
 # Default result for cluster UUID if not set
 UUID_NOT_SET = '** UUID NOT SET **'
 
@@ -205,30 +199,6 @@
     vhost = String(if_missing="/")
 
 
-class ConfigTFTP(Schema):
-    """Configuration validator for the TFTP service."""
-
-    if_key_missing = None
-
-    # Obsolete: old TFTP root directory.  This is retained for the purpose of
-    # deriving new, Simplestreams-based import configuration from previously
-    # imported boot images.
-    # The last time this is needed is for upgrading an older cluster
-    # controller to the Ubuntu 14.04 version of MAAS.  After installation of
-    # the 14.04 version, this setting is never used.
-    root = String(if_missing="/var/lib/maas/tftp")
-
-    # TFTP root directory, managed by the Simplestreams-based import script.
-    # The import script maintains "current" as a symlink pointing to the most
-    # recent images.
-    # XXX jtv 2014-05-22: Redundant with BOOT_RESOURCES_STORAGE.
-    resource_root = String(
-        if_missing=os.path.join(BOOT_RESOURCES_STORAGE, 'current/'))
-
-    port = Int(min=1, max=65535, if_missing=69)
-    generator = String(if_missing=b"http://localhost/MAAS/api/1.0/pxeconfig/")
-
-
 class ConfigLegacyEphemeral(Schema):
     """Legacy `ephemeral` section in `pserv.yaml` prior to MAAS 1.5.
 
@@ -415,7 +385,6 @@
     logfile = String(if_empty=b"pserv.log", if_missing=b"pserv.log")
     oops = ConfigOops
     broker = ConfigBroker
-    tftp = ConfigTFTP
     rpc = ConfigRPC
     boot = ConfigLegacyBoot
 
 
=== modified file 'src/provisioningserver/diskless.py'
--- src/provisioningserver/diskless.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/diskless.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -15,17 +15,21 @@
 __all__ = [
     'create_diskless_disk',
     'delete_diskless_disk',
-    ]
+]
 
 import os
 from textwrap import dedent
 
-from provisioningserver import config
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.drivers.diskless import DisklessDriverRegistry
 from provisioningserver.drivers.osystem import (
     BOOT_IMAGE_PURPOSE,
     OperatingSystemRegistry,
 )
+from provisioningserver.import_images.boot_resources import two_dir_levels_up
 from provisioningserver.logger import get_maas_logger
 from provisioningserver.utils.fs import (
     atomic_symlink,
@@ -48,7 +52,8 @@
     currently in use disk for diskless booting.
     """
     return os.path.join(
-        config.BOOT_RESOURCES_STORAGE, 'diskless', 'store')
+        two_dir_levels_up(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage)), 'diskless', 'store')
 
 
 def compose_diskless_link_path(system_id):
@@ -100,7 +105,9 @@
 def get_diskless_tgt_path():
     """Return path to maas-diskless.tgt."""
     return os.path.join(
-        config.BOOT_RESOURCES_STORAGE, 'diskless', 'maas-diskless.tgt')
+        two_dir_levels_up(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage)),
+        'diskless', 'maas-diskless.tgt')
 
 
 def tgt_entry(system_id, image):
@@ -145,7 +152,7 @@
         '/usr/sbin/tgt-admin',
         '--conf', get_diskless_tgt_path(),
         '--update', 'ALL',
-        ])
+    ])
 
 
 def update_diskless_tgt():
@@ -153,7 +160,7 @@
     symlinks in the diskless store. Reloads the tgt config."""
     tgt_path = get_diskless_tgt_path()
     tgt_config = compose_diskless_tgt_config()
-    atomic_write(tgt_config, tgt_path, mode=0644)
+    atomic_write(tgt_config, tgt_path, mode=0o644)
     reload_diskless_tgt()
 
 
@@ -184,7 +191,8 @@
             "OS doesn't support diskless booting: %s" % osystem_name)
     root_path, _ = osystem.get_xinstall_parameters()
     return os.path.join(
-        config.BOOT_RESOURCES_STORAGE, 'current',
+        get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage),
         osystem_name, arch, subarch, release, label, root_path)
 
 
 
=== modified file 'src/provisioningserver/drivers/osystem/custom.py'
--- src/provisioningserver/drivers/osystem/custom.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/drivers/osystem/custom.py	2015-05-04 14:27:25 +0000
@@ -7,18 +7,21 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
 __metaclass__ = type
 __all__ = [
     "CustomOS",
-    ]
+]
 
 import os
 
-from provisioningserver.config import BOOT_RESOURCES_STORAGE
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.drivers.osystem import (
     BOOT_IMAGE_PURPOSE,
     OperatingSystem,
@@ -55,8 +58,8 @@
 
     def get_xinstall_parameters(self, arch, subarch, release, label):
         """Returns the xinstall image name and type for given image."""
-        path = os.path.join(
-            BOOT_RESOURCES_STORAGE, 'current', 'custom',
+        path = os.path.join(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage), 'custom',
             arch, subarch, release, label)
         if os.path.exists(os.path.join(path, 'root-dd')):
             return "root-dd", "dd-tgz"
 
=== modified file 'src/provisioningserver/drivers/osystem/tests/test_custom.py'
--- src/provisioningserver/drivers/osystem/tests/test_custom.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/drivers/osystem/tests/test_custom.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -19,26 +19,34 @@
 
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
-from provisioningserver.drivers.osystem import custom
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
 from provisioningserver.drivers.osystem.custom import (
     BOOT_IMAGE_PURPOSE,
     CustomOS,
 )
+from provisioningserver.testing.config import ClusterConfigurationFixture
 
 
 class TestCustomOS(MAASTestCase):
 
     def make_resource_path(self, filename):
+        self.useFixture(ClusterConfigurationFixture())
         tmpdir = self.make_dir()
         arch = factory.make_name('arch')
         subarch = factory.make_name('subarch')
         release = factory.make_name('release')
         label = factory.make_name('label')
+        current_dir = os.path.join(tmpdir, 'current') + '/'
         dirpath = os.path.join(
-            tmpdir, 'current', 'custom', arch, subarch, release, label)
+            current_dir, 'custom', arch, subarch, release, label)
         os.makedirs(dirpath)
         factory.make_file(dirpath, filename)
-        self.patch(custom, 'BOOT_RESOURCES_STORAGE', tmpdir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            current_dir)
         return arch, subarch, release, label
 
     def test_get_boot_image_purposes(self):
@@ -54,7 +62,7 @@
             self.assertIsInstance(expected, list)
             self.assertEqual(expected, [
                 BOOT_IMAGE_PURPOSE.XINSTALL,
-                ])
+            ])
 
     def test_is_release_supported(self):
         osystem = CustomOS()
@@ -62,7 +70,7 @@
         supported = [
             osystem.is_release_supported(release)
             for release in releases
-            ]
+        ]
         self.assertEqual([True, True, True], supported)
 
     def test_get_default_release(self):
 
=== modified file 'src/provisioningserver/import_images/boot_resources.py'
--- src/provisioningserver/import_images/boot_resources.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/import_images/boot_resources.py	2015-05-04 14:27:25 +0000
@@ -5,7 +5,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -15,16 +15,19 @@
     'main',
     'main_with_services',
     'make_arg_parser',
-    ]
+]
 
 from argparse import ArgumentParser
 import errno
 import os
 from textwrap import dedent
 
-import provisioningserver
 from provisioningserver.boot import BootMethodRegistry
 from provisioningserver.boot.tftppath import list_boot_images
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.config import BootSources
 from provisioningserver.import_images.cleanup import (
     cleanup_snapshots_and_cache,
@@ -48,6 +51,16 @@
 from provisioningserver.utils.shell import call_and_check
 
 
+def two_dir_levels_up(path):
+    # NOTE: Syntax along the lines of:
+    #    os.path.normpath(os.path.join(
+    #       path, os.path.pardir, os.path.pardir))
+    # will NOT work here, as the classes that use these file paths
+    # to NOT support paths with 'os.path.pardir' segments. Thus
+    # we must manually resolve the path here.
+    return os.path.split(os.path.split(path)[0])[0]
+
+
 class NoConfigFile(Exception):
     """Raised when the config file for the script doesn't exist."""
 
@@ -81,7 +94,7 @@
         subarch,
         release,
         label
-        )
+    )
     entry = dedent("""\
         <target {prefix}:{target_name}>
             readonly 1
@@ -191,7 +204,7 @@
         '/usr/sbin/tgt-admin',
         '--conf', targets_conf,
         '--update', 'ALL',
-        ])
+    ])
 
 
 def read_sources(sources_yaml):
@@ -245,7 +258,8 @@
                 "any boot images available.")
             return
 
-        storage = provisioningserver.config.BOOT_RESOURCES_STORAGE
+        storage = two_dir_levels_up(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage))
         meta_file_content = image_descriptions.dump_json()
         if meta_contains(storage, meta_file_content):
             maaslog.info(
 
=== modified file 'src/provisioningserver/import_images/tests/test_boot_resources.py'
--- src/provisioningserver/import_images/tests/test_boot_resources.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/import_images/tests/test_boot_resources.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -39,14 +39,20 @@
 import mock
 from mock import call
 from provisioningserver.boot import BootMethodRegistry
-import provisioningserver.config
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
 from provisioningserver.config import BootSources
 from provisioningserver.import_images import boot_resources
 from provisioningserver.import_images.boot_image_mapping import (
     BootImageMapping,
 )
 from provisioningserver.import_images.testing.factory import make_image_spec
-from provisioningserver.testing.config import BootSourcesFixture
+from provisioningserver.testing.config import (
+    BootSourcesFixture,
+    ClusterConfigurationFixture,
+)
 from provisioningserver.utils.fs import write_text_file
 from testtools.content import Content
 from testtools.content_type import UTF8_TEXT
@@ -195,9 +201,13 @@
 
     def setUp(self):
         super(TestMain, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         self.storage = self.make_dir()
-        self.patch(
-            provisioningserver.config, 'BOOT_RESOURCES_STORAGE', self.storage)
+        current_dir = os.path.join(self.storage, 'current') + os.sep
+        os.makedirs(current_dir)
+        set_config_cluster_variable(CLUSTER_CONFIG.DB_boot_resources_storage,
+                                    current_dir)
+        os.rmdir(current_dir)
         # Forcing arch to amd64 causes pxelinux.0 to be installed, giving more
         # test coverage.
         self.image = make_image_spec(arch='amd64')
@@ -232,9 +242,9 @@
                     'updated': 'Tue, 25 Mar 2014 16:19:49 +0000',
                     'format': 'products:1.0',
                     'products': [product],
-                    },
                 },
-            }
+            },
+        }
         write_text_file(index_file, json.dumps(index))
         return index_file
 
@@ -251,7 +261,7 @@
             image_spec.release,
             image_spec.subarch,
             filename,
-            ]
+        ]
         native_path = os.path.join(repo, *path)
         os.makedirs(os.path.dirname(native_path))
         contents = ("Contents: %s" % filename).encode('utf-8')
@@ -318,7 +328,7 @@
         os_release = '%d.%.2s' % (
             randint(1, 99),
             ('04' if randint(0, 1) == 0 else '10'),
-            )
+        )
         repo = self.make_dir()
         index_dir = os.path.join(repo, 'streams', 'v1')
         os.makedirs(index_dir)
@@ -327,7 +337,7 @@
             os_release,
             image_spec.arch,
             image_spec.subarch,
-            )
+        )
         version = '20140317'
         download_file, sha = self.make_download_file(repo, image_spec, version)
         self.make_simplestreams_product_index(
@@ -350,9 +360,9 @@
                         'subarches': [self.subarch],
                         'labels': [self.label],
                     },
-                    ],
+                ],
             },
-            ]
+        ]
         sources_file = self.make_file(
             'sources.yaml', contents=yaml.safe_dump(sources))
         return self.make_args(sources_file=sources_file)
@@ -541,9 +551,9 @@
                         'subarches': [factory.make_name("subarch")],
                         'labels': [factory.make_name("label")],
                     },
-                    ],
+                ],
             },
-            ]
+        ]
         parsed_sources = boot_resources.parse_sources(yaml.safe_dump(sources))
         self.assertEqual(sources, parsed_sources)
 
@@ -577,9 +587,9 @@
                         'subarches': [factory.make_name("subarch")],
                         'labels': [factory.make_name("label")],
                     },
-                    ],
+                ],
             },
-            ],
+        ],
         boot_resources.import_images(sources)
         self.assertThat(
             fake_write_all_keyrings, MockCalledWith(mock.ANY, sources))
 
=== modified file 'src/provisioningserver/plugin.py'
--- src/provisioningserver/plugin.py	2015-04-29 06:19:04 +0000
+++ src/provisioningserver/plugin.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -17,10 +17,14 @@
 ]
 
 from errno import ENOPROTOOPT
-import os
 import socket
 from socket import error as socket_error
 
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+    get_tftp_generator,
+)
 from provisioningserver.utils.debug import (
     register_sigusr2_thread_dump_handler,
 )
@@ -93,7 +97,7 @@
     """Command line options for the provisioning server."""
 
     optParameters = [
-        ["config-file", "c", "pserv.yaml", "Configuration file to load."],
+        ["config-file", "c", "clusterd.conf", "Configuration file to load."],
         ["introspect", None, None,
          ("Allow introspection, allowing unhindered access to the internals "
           "of MAAS. This should probably only be used for debugging. Supply "
@@ -128,8 +132,6 @@
         from provisioningserver.pserv_services.image import (
             BootImageEndpointService)
         from twisted.internet.endpoints import AdoptedStreamServerEndpoint
-        from provisioningserver import config
-
         port = 5248  # config["port"]
         # Make a socket with SO_REUSEPORT set so that we can run multiple we
         # applications. This is easier to do from outside of Twisted as there's
@@ -157,59 +159,58 @@
         site_endpoint.socket = s  # Prevent garbage collection.
 
         image_service = BootImageEndpointService(
-            resource_root=os.path.join(
-                config.BOOT_RESOURCES_STORAGE, "current"),
+            resource_root=get_config_cluster_variable(
+                CLUSTER_CONFIG.DB_boot_resources_storage),
             endpoint=site_endpoint)
         image_service.setName("image_service")
         return image_service
 
-    def _makeTFTPService(self, tftp_config):
+    def _makeTFTPService(self, tftp_root, tftp_port, tftp_generator):
         """Create the dynamic TFTP service."""
         from provisioningserver.pserv_services.tftp import TFTPService
         tftp_service = TFTPService(
-            resource_root=tftp_config['resource_root'],
-            port=tftp_config['port'], generator=tftp_config['generator'])
+            resource_root=tftp_root, port=tftp_port, generator=tftp_generator)
         tftp_service.setName("tftp")
         return tftp_service
 
     def _makeImageDownloadService(self, rpc_service):
-        from provisioningserver.cluster_config import get_cluster_uuid
         from provisioningserver.pserv_services.image_download_service \
             import ImageDownloadService
         image_download_service = ImageDownloadService(
-            rpc_service, reactor, get_cluster_uuid())
+            rpc_service, reactor, get_config_cluster_variable(
+                CLUSTER_CONFIG.DB_cluster_uuid))
         image_download_service.setName("image_download")
         return image_download_service
 
     def _makeLeaseUploadService(self, rpc_service):
-        from provisioningserver.cluster_config import get_cluster_uuid
         from provisioningserver.pserv_services.lease_upload_service \
             import LeaseUploadService
         lease_upload_service = LeaseUploadService(
-            rpc_service, reactor, get_cluster_uuid())
+            rpc_service, reactor, get_config_cluster_variable(
+                CLUSTER_CONFIG.DB_cluster_uuid))
         lease_upload_service.setName("lease_upload")
         return lease_upload_service
 
     def _makeNodePowerMonitorService(self):
-        from provisioningserver.cluster_config import get_cluster_uuid
         from provisioningserver.pserv_services.node_power_monitor_service \
             import NodePowerMonitorService
-        node_monitor = NodePowerMonitorService(get_cluster_uuid(), reactor)
+        node_monitor = NodePowerMonitorService(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_cluster_uuid), reactor)
         node_monitor.setName("node_monitor")
         return node_monitor
 
-    def _makeRPCService(self, rpc_config):
+    def _makeRPCService(self):
         from provisioningserver.rpc.clusterservice import ClusterClientService
         rpc_service = ClusterClientService(reactor)
         rpc_service.setName("rpc")
         return rpc_service
 
     def _makeDHCPProbeService(self, rpc_service):
-        from provisioningserver.cluster_config import get_cluster_uuid
         from provisioningserver.pserv_services.dhcp_probe_service \
             import DHCPProbeService
         dhcp_probe_service = DHCPProbeService(
-            rpc_service, reactor, get_cluster_uuid())
+            rpc_service, reactor,
+            get_config_cluster_variable(CLUSTER_CONFIG.DB_cluster_uuid))
         dhcp_probe_service.setName("dhcp_probe")
         return dhcp_probe_service
 
@@ -226,17 +227,18 @@
         register_sigusr2_thread_dump_handler()
 
         from provisioningserver import services
-        from provisioningserver.config import Config
-
-        config = Config.load(options["config-file"])
 
         image_service = self._makeImageService()
         image_service.setServiceParent(services)
 
-        tftp_service = self._makeTFTPService(config["tftp"])
+        tftp_service = self._makeTFTPService(
+            get_config_cluster_variable(CLUSTER_CONFIG.DB_tftp_resource_root),
+            get_config_cluster_variable(CLUSTER_CONFIG.DB_tftpport),
+            get_tftp_generator())
+
         tftp_service.setServiceParent(services)
 
-        rpc_service = self._makeRPCService(config["rpc"])
+        rpc_service = self._makeRPCService()
         rpc_service.setServiceParent(services)
 
         node_monitor = self._makeNodePowerMonitorService()
 
=== modified file 'src/provisioningserver/pserv_services/tests/test_tftp.py'
--- src/provisioningserver/pserv_services/tests/test_tftp.py	2015-04-24 20:41:48 +0000
+++ src/provisioningserver/pserv_services/tests/test_tftp.py	2015-05-04 14:27:25 +0000
@@ -30,7 +30,6 @@
     urlparse,
 )
 
-from fixtures import EnvironmentVariable
 from maastesting.factory import factory
 from maastesting.matchers import (
     MockCalledOnceWith,
@@ -50,6 +49,7 @@
     IPV4_LINK_LOCAL,
     IPV6_LINK_LOCAL,
 )
+from provisioningserver import cluster_config
 from provisioningserver.boot import BytesReader
 from provisioningserver.boot.pxe import PXEBootMethod
 from provisioningserver.boot.tests.test_pxe import compose_config_path
@@ -63,6 +63,7 @@
     UDPServer,
 )
 from provisioningserver.rpc.testing import TwistedLoggerFixture
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
 from testtools import ExpectedException
 from testtools.matchers import (
@@ -127,6 +128,7 @@
 
     def setUp(self):
         super(TestTFTPBackend, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         from provisioningserver import boot
         self.patch(boot, "find_mac_via_arp")
         self.patch(tftp_module, 'log_request')
@@ -219,7 +221,8 @@
 
     @inlineCallbacks
     def test_get_reader_converts_404s_to_tftp_error(self):
-        self.useFixture(EnvironmentVariable("CLUSTER_UUID", "foobar"))
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid, factory.make_UUID())
 
         backend = TFTPBackend(self.make_dir(), "http://example.com/")
         get_page = self.patch(backend, 'get_page')
@@ -230,7 +233,8 @@
 
     @inlineCallbacks
     def test_get_reader_converts_other_exceptions_to_tftp_error(self):
-        self.useFixture(EnvironmentVariable("CLUSTER_UUID", "foobar"))
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid, factory.make_UUID())
 
         exception_type = factory.make_exception_type()
         exception_message = factory.make_string()
@@ -257,8 +261,8 @@
         # For paths matching PXEBootMethod.match_path, TFTPBackend.get_reader()
         # returns a Deferred that will yield a BytesReader.
         cluster_uuid = factory.make_UUID()
-        get_cluster_uuid = self.patch(tftp_module, 'get_cluster_uuid')
-        get_cluster_uuid.return_value = cluster_uuid
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid, cluster_uuid)
         mac = factory.make_mac_address("-")
         config_path = compose_config_path(mac)
         backend = TFTPBackend(self.make_dir(), b"http://example.com/")
@@ -356,8 +360,8 @@
         # arch field of the parameters (mapping from pxe to maas
         # namespace).
         cluster_uuid = factory.make_UUID()
-        get_cluster_uuid = self.patch(tftp_module, 'get_cluster_uuid')
-        get_cluster_uuid.return_value = cluster_uuid
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid, cluster_uuid)
         config_path = "pxelinux.cfg/default-arm"
         backend = TFTPBackend(self.make_dir(), b"http://example.com/")
         # python-tx-tftp sets up call context so that backends can discover
 
=== modified file 'src/provisioningserver/pserv_services/tftp.py'
--- src/provisioningserver/pserv_services/tftp.py	2015-04-24 20:39:18 +0000
+++ src/provisioningserver/pserv_services/tftp.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -15,7 +15,7 @@
 __all__ = [
     "TFTPBackend",
     "TFTPService",
-    ]
+]
 
 from functools import partial
 import httplib
@@ -35,7 +35,10 @@
     BootMethodRegistry,
     get_remote_mac,
 )
-from provisioningserver.cluster_config import get_cluster_uuid
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.drivers import ArchitectureRegistry
 from provisioningserver.events import (
     EVENT_TYPES,
@@ -223,7 +226,8 @@
         params["local"] = local_host
         remote_host, remote_port = tftp.get_remote_address()
         params["remote"] = remote_host
-        params["cluster_uuid"] = get_cluster_uuid()
+        params["cluster_uuid"] = get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_cluster_uuid)
         d = self.get_boot_method_reader(boot_method, params)
         return d
 
 
=== modified file 'src/provisioningserver/rpc/boot_images.py'
--- src/provisioningserver/rpc/boot_images.py	2015-02-24 13:52:12 +0000
+++ src/provisioningserver/rpc/boot_images.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -16,15 +16,17 @@
     "import_boot_images",
     "list_boot_images",
     "is_import_boot_images_running",
-    ]
+]
 
-import os
 from urlparse import urlparse
 
 from provisioningserver import concurrency
 from provisioningserver.auth import get_maas_user_gpghome
 from provisioningserver.boot import tftppath
-from provisioningserver.config import BOOT_RESOURCES_STORAGE
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.import_images import boot_resources
 from provisioningserver.utils.env import environment_variables
 from provisioningserver.utils.twisted import synchronous
@@ -41,10 +43,12 @@
     of IO, as this function is called often. To update the cache call
     `reload_boot_images`.
     """
+
     global CACHED_BOOT_IMAGES
     if CACHED_BOOT_IMAGES is None:
         CACHED_BOOT_IMAGES = tftppath.list_boot_images(
-            os.path.join(BOOT_RESOURCES_STORAGE, 'current'))
+            get_config_cluster_variable(
+                CLUSTER_CONFIG.DB_boot_resources_storage))
     return CACHED_BOOT_IMAGES
 
 
@@ -53,7 +57,7 @@
     most up-to-date boot images list."""
     global CACHED_BOOT_IMAGES
     CACHED_BOOT_IMAGES = tftppath.list_boot_images(
-        os.path.join(BOOT_RESOURCES_STORAGE, 'current'))
+        get_config_cluster_variable(CLUSTER_CONFIG.DB_boot_resources_storage))
 
 
 def get_hosts_from_sources(sources):
@@ -74,7 +78,7 @@
     """
     variables = {
         'GNUPGHOME': get_maas_user_gpghome(),
-        }
+    }
     if http_proxy is not None:
         variables['http_proxy'] = http_proxy
     if https_proxy is not None:
 
=== modified file 'src/provisioningserver/rpc/clusterservice.py'
--- src/provisioningserver/rpc/clusterservice.py	2015-04-22 16:51:55 +0000
+++ src/provisioningserver/rpc/clusterservice.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -27,8 +27,8 @@
 from apiclient.utils import ascii_url
 from provisioningserver import concurrency
 from provisioningserver.cluster_config import (
-    get_cluster_uuid,
-    get_maas_url,
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
 )
 from provisioningserver.drivers import (
     ArchitectureRegistry,
@@ -137,7 +137,8 @@
         Implementation of
         :py:class:`~provisioningserver.rpc.cluster.Identify`.
         """
-        return {b"ident": get_cluster_uuid().decode("ascii")}
+        return {b"ident": get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_cluster_uuid).decode("ascii")}
 
     @cluster.Authenticate.responder
     def authenticate(self, message):
@@ -194,8 +195,8 @@
             'architectures': [
                 {'name': arch.name, 'description': arch.description}
                 for _, arch in ArchitectureRegistry
-                ],
-            }
+            ],
+        }
 
     @cluster.ListOperatingSystems.responder
     def list_operating_systems(self):
@@ -258,7 +259,7 @@
                 osystem, interfaces, auto_interfaces, ips_mapping=ips_mapping,
                 gateways_mapping=gateways_mapping, disable_ipv4=disable_ipv4,
                 nameservers=nameservers, netmasks=netmasks),
-            }
+        }
 
     @cluster.PowerOn.responder
     def power_on(self, system_id, hostname, power_type, context):
@@ -523,9 +524,9 @@
         returnValue(digest == digest_local)
 
     def registerWithRegion(self):
-        uuid = get_cluster_uuid()
+        uuid = get_config_cluster_variable(CLUSTER_CONFIG.DB_cluster_uuid)
         networks = discover_networks()
-        url = get_maas_url()
+        url = get_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url)
 
         def cb_register(_):
             log.msg(
@@ -660,7 +661,7 @@
             scheme_ports = {
                 'https': 443,
                 'http': 80,
-                }
+            }
             defaultPort = scheme_ports.get(scheme, 80)
 
         if '[' in netloc:
@@ -775,7 +776,7 @@
     @staticmethod
     def _get_rpc_info_url():
         """Return the URL to the RPC infomation page on the region."""
-        url = urlparse(get_maas_url())
+        url = urlparse(get_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url))
         url = url._replace(path="%s/rpc/" % url.path.rstrip("/"))
         url = url.geturl()
         return ascii_url(url)
 
=== modified file 'src/provisioningserver/rpc/tags.py'
--- src/provisioningserver/rpc/tags.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/rpc/tags.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -22,13 +22,26 @@
     MAASOAuth,
 )
 from provisioningserver.cluster_config import (
-    get_cluster_uuid,
-    get_maas_url,
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+    set_config_cluster_variable,
 )
 from provisioningserver.tags import process_node_tags
 from provisioningserver.utils.twisted import synchronous
 
 
+def get_maas_url():
+    return get_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url)
+
+
+def get_cluster_uuid():
+    return get_config_cluster_variable(CLUSTER_CONFIG.DB_cluster_uuid)
+
+
+def set_maas_url(value):
+    return set_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url, value)
+
+
 @synchronous
 def evaluate_tag(tag_name, tag_definition, tag_nsmap, credentials):
     """Evaluate `tag_definition` against this cluster's nodes' details.
@@ -40,7 +53,9 @@
     """
     client = MAASClient(
         auth=MAASOAuth(*credentials), dispatcher=MAASDispatcher(),
-        base_url=get_maas_url())
+        base_url=get_config_cluster_variable(CLUSTER_CONFIG.DB_maas_url))
     process_node_tags(
         tag_name=tag_name, tag_definition=tag_definition, tag_nsmap=tag_nsmap,
-        client=client, nodegroup_uuid=get_cluster_uuid())
+        client=client,
+        nodegroup_uuid=get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_cluster_uuid))
 
=== modified file 'src/provisioningserver/rpc/tests/test_boot_images.py'
--- src/provisioningserver/rpc/tests/test_boot_images.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/rpc/tests/test_boot_images.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -29,7 +29,10 @@
 )
 from provisioningserver import concurrency
 from provisioningserver.boot import tftppath
-from provisioningserver.config import BOOT_RESOURCES_STORAGE
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.import_images import boot_resources
 from provisioningserver.rpc import boot_images
 from provisioningserver.rpc.boot_images import (
@@ -40,7 +43,10 @@
     list_boot_images,
     reload_boot_images,
 )
-from provisioningserver.testing.config import BootSourcesFixture
+from provisioningserver.testing.config import (
+    BootSourcesFixture,
+    ClusterConfigurationFixture,
+)
 from provisioningserver.testing.testcase import PservTestCase
 from provisioningserver.utils.twisted import pause
 from testtools.matchers import Equals
@@ -54,16 +60,20 @@
         'http://%s:%s/images-stream/streams/v1/index.json' % (
             host, randint(1, 1000))
         for host in hosts
-        ]
+    ]
     sources = [
         {'url': url, 'selections': []}
         for url in urls
-        ]
+    ]
     return sources, hosts
 
 
 class TestListBootImages(PservTestCase):
 
+    def setUp(self):
+        super(TestListBootImages, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
+
     def test__calls_list_boot_images_with_boot_resource_storage(self):
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
         mock_list_boot_images = self.patch(tftppath, 'list_boot_images')
@@ -71,7 +81,8 @@
         self.assertThat(
             mock_list_boot_images,
             MockCalledOnceWith(
-                os.path.join(BOOT_RESOURCES_STORAGE, "current")))
+                get_config_cluster_variable(
+                    CLUSTER_CONFIG.DB_boot_resources_storage)))
 
     def test__calls_list_boot_images_when_cache_is_None(self):
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
 
=== modified file 'src/provisioningserver/rpc/tests/test_clusterservice.py'
--- src/provisioningserver/rpc/tests/test_clusterservice.py	2015-04-22 16:51:55 +0000
+++ src/provisioningserver/rpc/tests/test_clusterservice.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -49,13 +49,12 @@
     Mock,
     sentinel,
 )
-from provisioningserver import concurrency
+from provisioningserver import (
+    cluster_config,
+    concurrency,
+)
 from provisioningserver.boot import tftppath
 from provisioningserver.boot.tests.test_tftppath import make_osystem
-from provisioningserver.cluster_config import (
-    get_cluster_uuid,
-    get_maas_url,
-)
 from provisioningserver.dhcp.testing.config import make_subnet_config
 from provisioningserver.drivers.osystem import (
     OperatingSystem,
@@ -106,6 +105,7 @@
     StubOS,
 )
 from provisioningserver.security import set_shared_secret_on_filesystem
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from testtools import ExpectedException
 from testtools.deferredruntest import extract_result
 from testtools.matchers import (
@@ -150,10 +150,11 @@
         self.assertIsNotNone(responder)
 
     def test_identify_reports_cluster_uuid(self):
+        self.useFixture(ClusterConfigurationFixture())
         example_uuid = factory.make_UUID()
 
-        get_cluster_uuid = self.patch(clusterservice, "get_cluster_uuid")
-        get_cluster_uuid.return_value = example_uuid
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid, example_uuid)
 
         d = call_responder(Cluster(), cluster.Identify, {})
 
@@ -239,6 +240,7 @@
 
     @inlineCallbacks
     def test_list_boot_images_with_things_to_report(self):
+        self.useFixture(ClusterConfigurationFixture())
         # tftppath.list_boot_images()'s return value matches the
         # response schema that ListBootImages declares, and is
         # serialised correctly.
@@ -258,7 +260,11 @@
         for options in product(osystems, archs, subarchs, releases, labels):
             os.makedirs(os.path.join(current_dir, *options))
             make_osystem(self, options[0], purposes)
-        self.patch(boot_images, 'BOOT_RESOURCES_STORAGE', tftpdir)
+
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_tftp_resource_root,
+            os.path.join(tftpdir, 'current/'))
+
         self.patch(boot_images, 'CACHED_BOOT_IMAGES', None)
 
         expected_images = [
@@ -272,7 +278,7 @@
             }
             for osystem, arch, subarch, release, label, purpose in product(
                 osystems, archs, subarchs, releases, labels, purposes)
-            ]
+        ]
         for expected_image in expected_images:
             if expected_image['purpose'] == 'xinstall':
                 expected_image['xinstall_path'] = 'root-tgz'
@@ -343,7 +349,7 @@
                 'sources': [],
                 'http_proxy': parsed_proxy,
                 'https_proxy': parsed_proxy,
-                })
+            })
 
         self.assertThat(
             import_boot_images,
@@ -465,9 +471,13 @@
         self.assertThat(service.clock, Is(sentinel.reactor))
 
     def test__get_rpc_info_url(self):
+        self.useFixture(ClusterConfigurationFixture())
+
         maas_url = "http://%s/%s/" % (
             factory.make_hostname(), factory.make_name("path"))
-        self.useFixture(EnvironmentVariable("MAAS_URL", maas_url))
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_maas_url,
+            maas_url)
         expected_rpc_info_url = maas_url + "rpc/"
         observed_rpc_info_url = ClusterClientService._get_rpc_info_url()
         self.assertThat(observed_rpc_info_url, Equals(expected_rpc_info_url))
@@ -1199,15 +1209,18 @@
 
     @inlineCallbacks
     def test_registerWithRegion_end_to_end(self):
+        self.useFixture(ClusterConfigurationFixture())
         fixture = self.useFixture(MockLiveClusterToRegionRPCFixture())
         protocol, connecting = fixture.makeEventLoop()
         self.addCleanup((yield connecting))
         yield getRegionClient()
         self.assertThat(
             protocol.Register, MockCalledOnceWith(
-                protocol, uuid=get_cluster_uuid(),
+                protocol, uuid=cluster_config.get_config_cluster_variable(
+                    cluster_config.CLUSTER_CONFIG.DB_cluster_uuid),
                 networks=discover_networks(),
-                url=urlparse(get_maas_url())))
+                url=urlparse(cluster_config.get_config_cluster_variable(
+                    cluster_config.CLUSTER_CONFIG.DB_maas_url))))
 
 
 class TestClusterProtocol_ListSupportedArchitectures(MAASTestCase):
@@ -1438,9 +1451,9 @@
                 'ips_mapping': {mac: [factory.make_ipv4_address()]},
                 'gateways_mapping': {mac: [factory.make_ipv4_address()]},
                 'nameservers': [],
-                },
+            },
             'disable_ipv4': factory.pick_bool(),
-            }
+        }
 
     def test__is_registered(self):
         protocol = Cluster()
@@ -1654,7 +1667,7 @@
         yield call_responder(Cluster(), self.command, {
             'omapi_key': omapi_key,
             'subnet_configs': subnet_configs,
-            })
+        })
 
         self.assertThat(DHCPServer, MockCalledOnceWith(omapi_key))
         self.assertThat(configure, MockCalledOnceWith(
@@ -1675,7 +1688,7 @@
         yield call_responder(Cluster(), self.command, {
             'omapi_key': factory.make_name('key'),
             'subnet_configs': [],
-            })
+        })
         self.assertFalse(concurrency.dhcp.locked)
 
     @inlineCallbacks
@@ -1692,7 +1705,7 @@
             yield call_responder(Cluster(), self.command, {
                 'omapi_key': omapi_key,
                 'subnet_configs': subnet_configs,
-                })
+            })
 
 
 class TestClusterProtocol_CreateHostMaps(MAASTestCase):
@@ -1905,7 +1918,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_virsh_and_enlist,
@@ -1923,7 +1936,7 @@
             "password": None,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_virsh_and_enlist,
@@ -1940,7 +1953,7 @@
             "poweraddr": poweraddr,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_virsh_and_enlist,
@@ -1962,7 +1975,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             clusterservice.maaslog.error,
             MockAnyCall(
@@ -1998,7 +2011,7 @@
             "protocol": protocol,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_vsphere_and_enlist,
@@ -2024,7 +2037,7 @@
             "protocol": None,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_vsphere_and_enlist,
@@ -2049,7 +2062,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_vsphere_and_enlist,
@@ -2076,7 +2089,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
 
         self.assertThat(
             clusterservice.maaslog.error,
@@ -2108,7 +2121,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
                 clusterservice.probe_esxi_and_enlist,
@@ -2133,7 +2146,7 @@
             "password": password,
             "prefix_filter": prefix_filter,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             clusterservice.maaslog.error,
             MockAnyCall(
@@ -2169,7 +2182,7 @@
             "password": password,
             "power_control": power_control,
             "accept_all": True,
-            })
+        })
 
         self.assertThat(
             find_ip_via_arp, MockCalledOnceWith(mac))
@@ -2195,7 +2208,7 @@
                 "password": password,
                 "power_control": power_control,
                 "accept_all": True,
-                })
+            })
 
         self.assertThat(
             maaslog.warning,
@@ -2221,7 +2234,7 @@
             "password": password,
             "power_control": power_control,
             "accept_all": True,
-            })
+        })
 
         self.assertThat(
             mock_deferToThread, MockCalledOnceWith(
@@ -2251,7 +2264,7 @@
             "password": password,
             "power_control": power_control,
             "accept_all": True,
-            })
+        })
         self.assertThat(
             clusterservice.maaslog.error,
             MockAnyCall(
 
=== modified file 'src/provisioningserver/rpc/tests/test_tags.py'
--- src/provisioningserver/rpc/tests/test_tags.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/rpc/tests/test_tags.py	2015-05-04 14:27:25 +0000
@@ -7,13 +7,14 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
 __metaclass__ = type
 __all__ = []
 
+
 from apiclient.maas_client import (
     MAASClient,
     MAASDispatcher,
@@ -26,17 +27,25 @@
     ANY,
     sentinel,
 )
+from provisioningserver import cluster_config
 from provisioningserver.rpc import tags
+from provisioningserver.testing.config import ClusterConfigurationFixture
 
 
 class TestEvaluateTag(MAASTestCase):
 
     def setUp(self):
         super(TestEvaluateTag, self).setUp()
-        get_maas_url = self.patch_autospec(tags, "get_maas_url")
-        get_maas_url.return_value = sentinel.maas_url
-        get_cluster_uuid = self.patch_autospec(tags, "get_cluster_uuid")
-        get_cluster_uuid.return_value = sentinel.cluster_uuid
+        self.useFixture(ClusterConfigurationFixture())
+
+        self.mock_cluster_uuid = factory.make_UUID()
+        self.mock_url = factory.make_simple_http_url()
+
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid,
+            self.mock_cluster_uuid)
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_maas_url, self.mock_url)
 
     def test__calls_process_node_tags(self):
         credentials = "aaa", "bbb", "ccc"
@@ -49,7 +58,7 @@
                 tag_name=sentinel.tag_name,
                 tag_definition=sentinel.tag_definition,
                 tag_nsmap=sentinel.tag_nsmap, client=ANY,
-                nodegroup_uuid=sentinel.cluster_uuid))
+                nodegroup_uuid=self.mock_cluster_uuid))
 
     def test__constructs_client_with_credentials(self):
         consumer_key = factory.make_name("ckey")
@@ -66,7 +75,7 @@
 
         client = tags.process_node_tags.call_args[1]["client"]
         self.assertIsInstance(client, MAASClient)
-        self.assertEqual(sentinel.maas_url, client.url)
+        self.assertEqual(self.mock_url, client.url)
         self.assertIsInstance(client.dispatcher, MAASDispatcher)
         self.assertIsInstance(client.auth, MAASOAuth)
         self.assertThat(tags.MAASOAuth, MockCalledOnceWith(
 
=== modified file 'src/provisioningserver/tests/test_cluster_config.py'
--- src/provisioningserver/tests/test_cluster_config.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/tests/test_cluster_config.py	2015-05-04 14:27:25 +0000
@@ -7,42 +7,83 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
 __metaclass__ = type
 __all__ = []
 
-from fixtures import EnvironmentVariableFixture
+import os
+
 from maastesting.factory import factory
 from maastesting.testcase import MAASTestCase
-from provisioningserver.cluster_config import (
-    get_cluster_uuid,
-    get_cluster_variable,
-    get_maas_url,
-)
-
-
-class TestClusterConfig(MAASTestCase):
-
-    def test_get_cluster_variable_reads_env(self):
-        var = factory.make_name('variable')
-        value = factory.make_name('value')
-        self.useFixture(EnvironmentVariableFixture(var, value))
-        self.assertEqual(value, get_cluster_variable(var))
-
-    def test_get_cluster_variable_fails_if_not_set(self):
-        self.assertRaises(
-            AssertionError,
-            get_cluster_variable, factory.make_name('nonexistent-variable'))
-
-    def test_get_cluster_uuid_reads_CLUSTER_UUID(self):
-        uuid = factory.make_name('uuid')
-        self.useFixture(EnvironmentVariableFixture('CLUSTER_UUID', uuid))
-        self.assertEqual(uuid, get_cluster_uuid())
-
-    def test_get_maas_url_reads_MAAS_URL(self):
-        maas_url = factory.make_name('maas_url')
-        self.useFixture(EnvironmentVariableFixture('MAAS_URL', maas_url))
-        self.assertEqual(maas_url, get_maas_url())
+from provisioningserver import cluster_config
+from provisioningserver.config import UUID_NOT_SET
+from provisioningserver.testing.config import ClusterConfigurationFixture
+
+
+class TestClusterConfigTFTPGenerator(MAASTestCase):
+    """Tests for the get_tftp_generator() function."""
+
+    def test_get_tftp_generator(self):
+        self.useFixture(ClusterConfigurationFixture())
+        random_path = factory.make_simple_http_url()
+        cluster_config.set_config_cluster_variable(
+            cluster_config.CLUSTER_CONFIG.DB_maas_url, random_path)
+
+        observed = cluster_config.get_tftp_generator()
+        expected = os.path.join(random_path, 'api', '1.0', 'pxeconfig')
+        self.assertEqual(observed, expected)
+
+
+class TestClusterConfigDatabaseOptions(MAASTestCase):
+    """Tests for the database options in `cluster_config`."""
+
+    def setUp(self):
+        super(TestClusterConfigDatabaseOptions, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
+
+    options_and_defaults = {
+        cluster_config.CLUSTER_CONFIG.DB_cluster_uuid: UUID_NOT_SET,
+        cluster_config.CLUSTER_CONFIG.DB_maas_url:
+        "http://localhost:5240/MAAS",
+        cluster_config.CLUSTER_CONFIG.DB_tftp_resource_root:
+        "/var/lib/maas/boot-resources/current/",
+        cluster_config.CLUSTER_CONFIG.DB_boot_resources_storage:
+        "/var/lib/maas/boot-resources/current/",
+        cluster_config.CLUSTER_CONFIG.DB_tftpport: 69,
+    }
+
+    scenarios = tuple(
+        (name, {"option": name, "default": default})
+        for name, default in options_and_defaults.viewitems()
+    )
+
+    def test__default(self):
+        self.assertEqual(
+            self.default,
+            cluster_config.get_config_cluster_variable(self.option))
+
+    def test__set_and_get(self):
+        # NOTE: test_values cannot be a class attribute factory
+        # since make_dir() requires a reference to 'self' for the
+        # TempDirectory fixture.
+        test_values = {
+            cluster_config.CLUSTER_CONFIG.DB_cluster_uuid: factory.make_UUID(),
+            cluster_config.CLUSTER_CONFIG.DB_maas_url:
+            factory.make_simple_http_url(),
+            cluster_config.CLUSTER_CONFIG.DB_tftp_resource_root:
+            self.make_dir(),
+            cluster_config.CLUSTER_CONFIG.DB_boot_resources_storage:
+            self.make_dir(),
+            cluster_config.CLUSTER_CONFIG.DB_tftpport: factory.pick_port(),
+        }
+
+        example_value = test_values[self.option]
+
+        cluster_config.set_config_cluster_variable(self.option, example_value)
+
+        self.assertEqual(example_value,
+                         cluster_config.get_config_cluster_variable(
+                             self.option))
 
=== modified file 'src/provisioningserver/tests/test_config.py'
--- src/provisioningserver/tests/test_config.py	2015-05-04 14:27:25 +0000
+++ src/provisioningserver/tests/test_config.py	2015-05-04 14:27:25 +0000
@@ -15,24 +15,17 @@
 __all__ = []
 
 import contextlib
-from copy import deepcopy
-import errno
-from functools import partial
-from getpass import getuser
-from io import BytesIO
 from operator import methodcaller
 import os.path
 import random
 import re
 import sqlite3
-from textwrap import dedent
 from uuid import uuid4
 
 from fixtures import EnvironmentVariableFixture
 import formencode
 import formencode.validators
 from formencode.validators import Invalid
-from maastesting import root
 from maastesting.factory import factory
 from maastesting.matchers import (
     MockCalledOnceWith,
@@ -41,11 +34,7 @@
 from maastesting.testcase import MAASTestCase
 from mock import sentinel
 from provisioningserver.config import (
-    BootSources,
     ClusterConfiguration,
-    Config,
-    ConfigBase,
-    ConfigMeta,
     Configuration,
     ConfigurationDatabase,
     ConfigurationFile,
@@ -56,17 +45,13 @@
     UUID,
 )
 from provisioningserver.path import get_path
-from provisioningserver.testing.config import ConfigFixtureBase
 from provisioningserver.utils.fs import FileLockProxy
 from testtools import ExpectedException
 from testtools.matchers import (
-    DirExists,
     FileContains,
     FileExists,
     Is,
-    MatchesException,
     MatchesStructure,
-    Raises,
 )
 from twisted.python.filepath import FilePath
 import yaml
@@ -224,444 +209,6 @@
                              "url: %s" % url)
 
 
-class ExampleConfig(ConfigBase, formencode.Schema):
-    """An example configuration schema.
-
-    It derives from :class:`ConfigBase` and has a metaclass derived from
-    :class:`ConfigMeta`, just as a "real" schema must.
-    """
-
-    class __metaclass__(ConfigMeta):
-        envvar = "MAAS_TESTING_SETTINGS"
-        default = "example.yaml"
-
-    something = formencode.validators.String(if_missing="*missing*")
-
-
-class ExampleConfigFixture(ConfigFixtureBase):
-    """A fixture to help with testing :class:`ExampleConfig`."""
-
-    schema = ExampleConfig
-
-
-class TestConfigFixtureBase(MAASTestCase):
-    """Tests for `ConfigFixtureBase`."""
-
-    def exercise_fixture(self, fixture):
-        # ConfigFixtureBase arranges a minimal configuration on disk,
-        # and exports the configuration filename to the environment so
-        # that subprocesses can find it.
-        with fixture:
-            self.assertThat(fixture.dir, DirExists())
-            self.assertThat(fixture.filename, FileExists())
-            self.assertEqual(
-                {fixture.schema.envvar: fixture.filename},
-                fixture.environ)
-            self.assertEqual(
-                fixture.filename, os.environ[fixture.schema.envvar])
-            with open(fixture.filename, "rb") as stream:
-                self.assertEqual(fixture.config, yaml.safe_load(stream))
-
-    def test_use_minimal(self):
-        # With no arguments, ConfigFixtureBase arranges a minimal
-        # configuration.
-        fixture = ExampleConfigFixture()
-        self.exercise_fixture(fixture)
-
-    def test_use_with_config(self):
-        # Given a configuration, ConfigFixtureBase can arrange a minimal
-        # global configuration with the additional options merged in.
-        something = self.getUniqueString("something")
-        fixture = ExampleConfigFixture({"something": something})
-        self.assertEqual(something, fixture.config["something"])
-        self.exercise_fixture(fixture)
-
-
-class TestConfigMeta_DEFAULT_FILENAME(MAASTestCase):
-    """Tests for `provisioningserver.config.ConfigBase.DEFAULT_FILENAME`."""
-
-    def set_envvar(self, filepath=None):
-        """Continue this test with a given environment variable."""
-        self.useFixture(EnvironmentVariableFixture(
-            ExampleConfig.envvar, filepath))
-
-    def set_MAAS_CONFIG_DIR(self, dirpath=None):
-        """Continue this test with a given `MAAS_CONFIG_DIR`."""
-        self.useFixture(EnvironmentVariableFixture("MAAS_CONFIG_DIR", dirpath))
-
-    def make_config(self):
-        """Create a config file in a directory of its own."""
-        return self.make_file(name=ExampleConfig.default)
-
-    def test_gets_filename_from_MAAS_PROVISIONING_SETTNGS(self):
-        dummy_filename = factory.make_name("config")
-        self.set_MAAS_CONFIG_DIR(None)
-        self.set_envvar(dummy_filename)
-        self.assertEqual(dummy_filename, ExampleConfig.DEFAULT_FILENAME)
-
-    def test_falls_back_to_MAAS_CONFIG_DIR(self):
-        config_file = self.make_config()
-        self.set_MAAS_CONFIG_DIR(os.path.dirname(config_file))
-        self.set_envvar(None)
-        self.assertEqual(config_file, ExampleConfig.DEFAULT_FILENAME)
-
-    def test_MAAS_PROVISIONING_SETTINGS_trumps_MAAS_CONFIG_DIR(self):
-        provisioning_settings = factory.make_name("config")
-        self.set_MAAS_CONFIG_DIR(os.path.dirname(self.make_config()))
-        self.set_envvar(provisioning_settings)
-        self.assertEqual(
-            provisioning_settings,
-            ExampleConfig.DEFAULT_FILENAME)
-
-    def test_defaults_to_global_config(self):
-        self.set_MAAS_CONFIG_DIR(None)
-        self.set_envvar(None)
-        self.assertEqual(
-            '/etc/maas/%s' % ExampleConfig.default,
-            ExampleConfig.DEFAULT_FILENAME)
-
-    def test_set(self):
-        dummy_filename = factory.make_name("config")
-        ExampleConfig.DEFAULT_FILENAME = dummy_filename
-        self.assertEqual(dummy_filename, ExampleConfig.DEFAULT_FILENAME)
-
-    def test_delete(self):
-        self.set_MAAS_CONFIG_DIR(None)
-        self.set_envvar(None)
-        ExampleConfig.DEFAULT_FILENAME = factory.make_name("config")
-        del ExampleConfig.DEFAULT_FILENAME
-        # The filename reverts; see test_get_with_environment_empty.
-        self.assertEqual(
-            "/etc/maas/%s" % ExampleConfig.default,
-            ExampleConfig.DEFAULT_FILENAME)
-        # The delete does not fail when called multiple times.
-        del ExampleConfig.DEFAULT_FILENAME
-
-
-class TestConfigBase(MAASTestCase):
-    """Tests for `provisioningserver.config.ConfigBase`."""
-
-    def make_config_data(self):
-        """Return random config data for `ExampleConfig`."""
-        return {'something': factory.make_name('value')}
-
-    def make_config_file(self, name=None, data=None):
-        """Write a YAML config file, and return its path."""
-        if name is None:
-            name = factory.make_name('config') + '.yaml'
-        if data is None:
-            data = self.make_config_data()
-        return self.make_file(name=name, contents=yaml.safe_dump(data))
-
-    def test_get_defaults_returns_default_config(self):
-        # The default configuration is production-ready.
-        observed = ExampleConfig.get_defaults()
-        self.assertEqual({"something": "*missing*"}, observed)
-
-    def test_get_defaults_ignores_settings(self):
-        self.useFixture(ExampleConfigFixture(self.make_config_data()))
-        observed = ExampleConfig.get_defaults()
-        self.assertEqual({"something": "*missing*"}, observed)
-
-    def test_parse(self):
-        # Configuration can be parsed from a snippet of YAML.
-        observed = ExampleConfig.parse(b'something: "important"\n')
-        self.assertEqual("important", observed["something"])
-
-    def test_load(self):
-        # Configuration can be loaded and parsed from a file.
-        config = dedent("""
-            something: "important"
-            """)
-        filename = self.make_file(contents=config)
-        observed = ExampleConfig.load(filename)
-        self.assertEqual({"something": "important"}, observed)
-
-    def test_load_defaults_to_default_filename(self):
-        data = self.make_config_data()
-        filename = self.make_config_file(name='config.yaml', data=data)
-        self.patch(ExampleConfig, 'DEFAULT_FILENAME', filename)
-        self.assertEqual(data, ExampleConfig.load())
-
-    def test_load_from_cache_loads_config(self):
-        data = self.make_config_data()
-        filename = self.make_config_file(data=data)
-        self.assertEqual(data, ExampleConfig.load_from_cache(filename))
-
-    def test_load_from_cache_uses_defaults(self):
-        filename = self.make_file(contents='')
-        self.assertEqual(
-            ExampleConfig.get_defaults(),
-            ExampleConfig.load_from_cache(filename))
-
-    def test_load_from_cache_caches_each_file_separately(self):
-        config1 = self.make_file(contents=yaml.safe_dump({'something': "1"}))
-        config2 = self.make_file(contents=yaml.safe_dump({'something': "2"}))
-
-        self.assertEqual(
-            {"something": "1"},
-            ExampleConfig.load_from_cache(config1))
-        self.assertEqual(
-            {"something": "2"},
-            ExampleConfig.load_from_cache(config2))
-
-    def test_load_from_cache_reloads_from_cache_not_from_file(self):
-        # A config loaded by Config.load_from_cache() is never reloaded.
-        filename = self.make_config_file()
-        config_before = ExampleConfig.load_from_cache(filename)
-        os.unlink(filename)
-        config_after = ExampleConfig.load_from_cache(filename)
-        self.assertEqual(config_before, config_after)
-
-    def test_load_from_cache_caches_immutable_copy(self):
-        filename = self.make_config_file()
-
-        first_load = ExampleConfig.load_from_cache(filename)
-        second_load = ExampleConfig.load_from_cache(filename)
-
-        self.assertEqual(first_load, second_load)
-        self.assertIsNot(first_load, second_load)
-        first_load['something'] = factory.make_name('newthing')
-        self.assertNotEqual(first_load['something'], second_load['something'])
-
-    def test_flush_cache_without_filename_empties_cache(self):
-        filename = self.make_config_file()
-        ExampleConfig.load_from_cache(filename)
-        os.unlink(filename)
-        ExampleConfig.flush_cache()
-        error = self.assertRaises(
-            IOError,
-            ExampleConfig.load_from_cache, filename)
-        self.assertEqual(errno.ENOENT, error.errno)
-
-    def test_flush_cache_flushes_specific_file(self):
-        filename = self.make_config_file()
-        ExampleConfig.load_from_cache(filename)
-        os.unlink(filename)
-        ExampleConfig.flush_cache(filename)
-        error = self.assertRaises(
-            IOError,
-            ExampleConfig.load_from_cache, filename)
-        self.assertEqual(errno.ENOENT, error.errno)
-
-    def test_flush_cache_retains_other_files(self):
-        flushed_file = self.make_config_file()
-        cached_file = self.make_config_file()
-        ExampleConfig.load_from_cache(flushed_file)
-        cached_config = ExampleConfig.load_from_cache(cached_file)
-        os.unlink(cached_file)
-        ExampleConfig.flush_cache(flushed_file)
-        self.assertEqual(
-            cached_config,
-            ExampleConfig.load_from_cache(cached_file))
-
-    def test_flush_cache_ignores_uncached_files(self):
-        data = self.make_config_data()
-        filename = self.make_config_file(data=data)
-        ExampleConfig.flush_cache(filename)
-        self.assertEqual(data, ExampleConfig.load_from_cache(filename))
-
-    def test_field(self):
-        self.assertIs(ExampleConfig, ExampleConfig.field())
-        self.assertIs(
-            ExampleConfig.fields["something"],
-            ExampleConfig.field("something"))
-
-    def test_save_and_load_interoperate(self):
-        something = self.getUniqueString()
-        saved_file = self.make_file()
-
-        ExampleConfig.save({'something': something}, saved_file)
-        loaded_config = ExampleConfig.load(saved_file)
-        self.assertEqual(something, loaded_config['something'])
-
-    def test_save_saves_yaml_file(self):
-        config = {'something': self.getUniqueString()}
-        saved_file = self.make_file()
-
-        ExampleConfig.save(config, saved_file)
-
-        with open(saved_file, 'rb') as written_file:
-            loaded_config = yaml.safe_load(written_file)
-        self.assertEqual(config, loaded_config)
-
-    def test_save_defaults_to_default_filename(self):
-        something = self.getUniqueString()
-        filename = self.make_file(name="config.yaml")
-        self.patch(ExampleConfig, 'DEFAULT_FILENAME', filename)
-
-        ExampleConfig.save({'something': something})
-
-        self.assertEqual(
-            {'something': something},
-            ExampleConfig.load(filename))
-
-    def test_create_backup_creates_backup(self):
-        something = self.getUniqueString()
-        filename = self.make_file(name="config.yaml")
-        config = {'something': something}
-        yaml_config = yaml.safe_dump(config)
-        self.patch(ExampleConfig, 'DEFAULT_FILENAME', filename)
-        ExampleConfig.save(config)
-
-        ExampleConfig.create_backup('test')
-
-        backup_name = "%s.%s.bak" % (filename, 'test')
-        self.assertThat(backup_name, FileContains(yaml_config))
-
-
-class TestConfig(MAASTestCase):
-    """Tests for `provisioningserver.config.Config`."""
-
-    default_production_config = {
-        'broker': {
-            'host': 'localhost',
-            'port': 5673,
-            'username': getuser(),
-            'password': 'test',
-            'vhost': '/',
-        },
-        'logfile': 'pserv.log',
-        'oops': {
-            'directory': '',
-            'reporter': '',
-        },
-        'rpc': {},
-        'tftp': {
-            'generator': 'http://localhost/MAAS/api/1.0/pxeconfig/',
-            'port': 69,
-            # The "root" setting is obsolete; resource_root replaces it.
-            'root': "/var/lib/maas/tftp",
-            'resource_root': "/var/lib/maas/boot-resources/current/",
-        },
-        # Legacy section.  Became unused in MAAS 1.5.
-        'boot': {
-            'architectures': None,
-            'ephemeral': {
-                'images_directory': None,
-                'releases': None,
-            },
-        },
-    }
-
-    default_development_config = deepcopy(default_production_config)
-    default_development_config.update(logfile="/dev/null")
-    default_development_config["tftp"].update(
-        port=5244, generator="http://localhost:5240/MAAS/api/1.0/pxeconfig/")
-
-    def test_get_defaults_returns_default_config(self):
-        # The default configuration is production-ready.
-        observed = Config.get_defaults()
-        self.assertEqual(self.default_production_config, observed)
-
-    def test_load_example(self):
-        # The example configuration is designed for development.
-        filename = os.path.join(root, "etc", "maas", "pserv.yaml")
-        self.assertEqual(
-            self.default_development_config,
-            Config.load(filename))
-
-    def test_oops_directory_without_reporter(self):
-        # It is an error to omit the OOPS reporter if directory is specified.
-        config = (
-            'oops:\n'
-            '  directory: /tmp/oops\n'
-        )
-        expected = MatchesException(
-            formencode.Invalid, "oops: You must give a value for reporter")
-        self.assertThat(
-            partial(Config.parse, config),
-            Raises(expected))
-
-    def test_accepts_1_4_config_file(self):
-        # A config file that was valid with MAAS 1.4 still loads, even though
-        # its "boot" section is no longer used.
-        broker_password = factory.make_name('pass')
-        config = Config.parse(dedent("""\
-            logfile: "/dev/null"
-            oops:
-              directory: "logs/oops"
-              reporter: "maas-pserv"
-            broker:
-              host: "localhost"
-              port: 5673
-              username: brokeruser
-              password: "%s"
-              vhost: "/"
-            tftp:
-              root: /var/lib/maas/tftp
-              port: 5244
-              generator: http://localhost:5240/api/1.0/pxeconfig/
-            boot:
-              architectures: ['i386', 'armhf']
-              ephemeral:
-                images_directory: /var/lib/maas/ephemeral
-                releases: ['precise', 'saucy']
-            """) % broker_password)
-        # This does not fail.
-        self.assertEqual(broker_password, config['broker']['password'])
-
-
-class TestBootSources(MAASTestCase):
-    """Tests for `provisioningserver.config.BootSources`."""
-
-    default_source = {
-        'url': (
-            'http://maas.ubuntu.com/images/ephemeral-v2/releases/'
-        ),
-        'keyring': (
-            '/usr/share/keyrings/ubuntu-cloudimage-keyring.gpg'),
-        'keyring_data': None,
-        'selections': [
-            {
-                'os': '*',
-                'release': '*',
-                'labels': ['*'],
-                'arches': ['*'],
-                'subarches': ['*'],
-            },
-        ],
-    }
-
-    def make_source(self):
-        """Create a dict defining an arbitrary `BootSource`."""
-        return {
-            'url': 'http://example.com/' + factory.make_name('path'),
-            'keyring': factory.make_name('keyring'),
-            'keyring_data': factory.make_string(),
-            'selections': [{
-                'os': factory.make_name('os'),
-                'release': factory.make_name('release'),
-                'labels': [factory.make_name('label')],
-                'arches': [factory.make_name('arch')],
-                'subarches': [factory.make_name('sub') for _ in range(3)],
-            }],
-        }
-
-    def test_parse_parses_source(self):
-        sources = [self.make_source()]
-        self.assertEqual(
-            sources,
-            BootSources.parse(BytesIO(yaml.safe_dump(sources))))
-
-    def test_parse_parses_multiple_sources(self):
-        sources = [self.make_source() for _ in range(2)]
-        self.assertEqual(
-            sources,
-            BootSources.parse(BytesIO(yaml.safe_dump(sources))))
-
-    def test_parse_uses_defaults(self):
-        self.assertEqual(
-            [self.default_source],
-            BootSources.parse(BytesIO(b'[{}]')))
-
-    def test_load_parses_file(self):
-        sources = [self.make_source()]
-        self.assertEqual(
-            sources,
-            BootSources.load(self.make_file(contents=yaml.safe_dump(sources))))
-
-
 ###############################################################################
 # New configuration API follows.
 ###############################################################################
 
=== modified file 'src/provisioningserver/tests/test_diskless.py'
--- src/provisioningserver/tests/test_diskless.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/tests/test_diskless.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -24,9 +24,11 @@
 )
 from maastesting.testcase import MAASTestCase
 from mock import sentinel
-from provisioningserver import (
-    config,
-    diskless,
+from provisioningserver import diskless
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+    set_config_cluster_variable,
 )
 from provisioningserver.diskless import (
     compose_diskless_link_path,
@@ -54,6 +56,7 @@
     BOOT_IMAGE_PURPOSE,
     OperatingSystemRegistry,
 )
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.testing.os import FakeOS
 from provisioningserver.utils.testing import RegistryFixture
 from testtools.matchers import (
@@ -71,13 +74,18 @@
 
     def setUp(self):
         super(DisklessTestMixin, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         # Ensure the global registry is empty for each test run.
         self.useFixture(RegistryFixture())
 
     def configure_resource_storage(self):
         resource_dir = self.make_dir()
         os.mkdir(os.path.join(resource_dir, 'diskless'))
-        self.patch(config, 'BOOT_RESOURCES_STORAGE', resource_dir)
+        current_dir = os.path.join(resource_dir, 'current') + '/'
+        os.mkdir(current_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            current_dir)
         return resource_dir
 
     def configure_diskless_storage(self):
@@ -116,8 +124,12 @@
 class TestHelpers(MAASTestCase, DisklessTestMixin):
 
     def test_get_diskless_store(self):
-        storage_dir = factory.make_name('storage')
-        self.patch(config, 'BOOT_RESOURCES_STORAGE', storage_dir)
+        storage_dir = self.make_dir()
+        current_dir = os.path.join(storage_dir, 'current') + '/'
+        os.mkdir(current_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage,
+            current_dir)
         self.assertEqual(
             os.path.join(storage_dir, 'diskless', 'store'),
             get_diskless_store())
@@ -241,7 +253,7 @@
                 '%s</target>\n' % entry
                 for entry in tgt_output.split('</target>\n')
                 if entry != ""
-                ])
+            ])
 
     def test_reload_diskless_tgt(self):
         tgt_path = factory.make_name('tgt_path')
@@ -255,7 +267,7 @@
                 '/usr/sbin/tgt-admin',
                 '--conf', tgt_path,
                 '--update', 'ALL',
-                ]))
+            ]))
 
     def test_update_diskless_tgt_calls_atomic_write(self):
         tgt_path = factory.make_name('tgt_path')
@@ -269,7 +281,7 @@
         update_diskless_tgt()
         self.assertThat(
             mock_write,
-            MockCalledOnceWith(tgt_config, tgt_path, mode=0644))
+            MockCalledOnceWith(tgt_config, tgt_path, mode=0o644))
 
 
 class TestComposeSourcePath(MAASTestCase, DisklessTestMixin):
@@ -299,7 +311,8 @@
         mock_xi_params.return_value = (root_path, 'tgz')
         self.assertEqual(
             os.path.join(
-                config.BOOT_RESOURCES_STORAGE, 'current', os_name,
+                get_config_cluster_variable(
+                    CLUSTER_CONFIG.DB_boot_resources_storage), os_name,
                 arch, subarch, release, label, root_path),
             compose_source_path(os_name, arch, subarch, release, label))
 
@@ -337,7 +350,7 @@
         driver_options = {
             factory.make_name('arg'): factory.make_name('value')
             for _ in range(3)
-            }
+        }
         create_diskless_disk(
             driver.name, driver_options,
             system_id, sentinel.osystem, sentinel.arch,
@@ -451,7 +464,7 @@
         driver_options = {
             factory.make_name('arg'): factory.make_name('value')
             for _ in range(3)
-            }
+        }
         delete_diskless_disk(driver.name, driver_options, system_id)
         self.assertThat(
             mock_delete,
 
=== modified file 'src/provisioningserver/tests/test_plugin.py'
--- src/provisioningserver/tests/test_plugin.py	2015-04-29 06:19:04 +0000
+++ src/provisioningserver/tests/test_plugin.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -16,13 +16,16 @@
 
 import os
 
-from fixtures import EnvironmentVariableFixture
-from maastesting.factory import factory
 from maastesting.testcase import (
     MAASTestCase,
     MAASTwistedRunTest,
 )
 import provisioningserver
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+    get_tftp_generator,
+)
 from provisioningserver.plugin import (
     Options,
     ProvisioningRealm,
@@ -43,6 +46,7 @@
     TFTPBackend,
     TFTPService,
 )
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from testtools.deferredruntest import assert_fails_with
 from testtools.matchers import (
     AfterPreprocessing,
@@ -56,7 +60,6 @@
 from twisted.cred.error import UnauthorizedLogin
 from twisted.internet.defer import inlineCallbacks
 from twisted.web.resource import IResource
-import yaml
 
 
 class TestOptions(MAASTestCase):
@@ -64,7 +67,7 @@
 
     def test_defaults(self):
         options = Options()
-        expected = {"config-file": "pserv.yaml", "introspect": None}
+        expected = {"config-file": "clusterd.conf", "introspect": None}
         self.assertEqual(expected, options.defaults)
 
     def test_parse_minimal_options(self):
@@ -81,17 +84,9 @@
 
     def setUp(self):
         super(TestProvisioningServiceMaker, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
         self.patch(provisioningserver, "services", MultiService())
         self.tempdir = self.make_dir()
-        self.useFixture(
-            EnvironmentVariableFixture(
-                "CLUSTER_UUID", factory.make_UUID()))
-
-    def write_config(self, config):
-        config_filename = os.path.join(self.tempdir, "config.yaml")
-        with open(config_filename, "wb") as stream:
-            yaml.safe_dump(config, stream)
-        return config_filename
 
     def test_init(self):
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
@@ -103,14 +98,13 @@
         Only the site service is created when no options are given.
         """
         options = Options()
-        options["config-file"] = self.write_config({})
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
         service = service_maker.makeService(options)
         self.assertIsInstance(service, MultiService)
         expected_services = [
             "dhcp_probe", "image_download", "lease_upload",
             "node_monitor", "rpc", "tftp", "image_service"
-            ]
+        ]
         self.assertItemsEqual(expected_services, service.namedServices)
         self.assertEqual(
             len(service.namedServices), len(service.services),
@@ -119,7 +113,6 @@
 
     def test_image_download_service(self):
         options = Options()
-        options["config-file"] = self.write_config({})
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
         service = service_maker.makeService(options)
         image_service = service.getServiceNamed("image_download")
@@ -127,7 +120,6 @@
 
     def test_node_monitor_service(self):
         options = Options()
-        options["config-file"] = self.write_config({})
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
         service = service_maker.makeService(options)
         node_monitor = service.getServiceNamed("node_monitor")
@@ -135,7 +127,6 @@
 
     def test_dhcp_probe_service(self):
         options = Options()
-        options["config-file"] = self.write_config({})
         service_maker = ProvisioningServiceMaker("Spike", "Milligan")
         service = service_maker.makeService(options)
         dhcp_probe = service.getServiceNamed("dhcp_probe")
@@ -143,15 +134,7 @@
 
     def test_tftp_service(self):
         # A TFTP service is configured and added to the top-level service.
-        config = {
-            "tftp": {
-                "generator": "http://candlemass/solitude",
-                "resource_root": self.tempdir,
-                "port": factory.pick_port(),
-                },
-            }
         options = Options()
-        options["config-file"] = self.write_config(config)
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
         service = service_maker.makeService(options)
         tftp_service = service.getServiceNamed("tftp")
@@ -161,24 +144,25 @@
             IsInstance(TFTPBackend),
             AfterPreprocessing(
                 lambda backend: backend.base.path,
-                Equals(config["tftp"]["resource_root"])),
+                Equals(os.path.split(
+                    get_config_cluster_variable(
+                        CLUSTER_CONFIG.DB_tftp_resource_root))[0])),
             AfterPreprocessing(
                 lambda backend: backend.generator_url.geturl(),
-                Equals(config["tftp"]["generator"])))
+                Equals(get_tftp_generator())))
 
         self.assertThat(
             tftp_service, MatchesStructure(
                 backend=expected_backend,
-                port=Equals(config["tftp"]["port"]),
+                port=Equals(get_config_cluster_variable(
+                    CLUSTER_CONFIG.DB_tftpport)),
             ))
 
     def test_image_service(self):
-        from provisioningserver import config
         from twisted.web.server import Site
         from twisted.python.filepath import FilePath
 
         options = Options()
-        options["config-file"] = self.write_config({})
         service_maker = ProvisioningServiceMaker("Harry", "Hill")
         service = service_maker.makeService(options)
         image_service = service.getServiceNamed("image_service")
@@ -189,8 +173,9 @@
             "images", request=None)
         self.assertThat(root, IsInstance(FilePath))
 
-        resource_root = os.path.join(
-            config.BOOT_RESOURCES_STORAGE, "current")
+        resource_root = os.path.split(
+            get_config_cluster_variable(
+                CLUSTER_CONFIG.DB_tftp_resource_root))[0]
 
         self.assertEqual(resource_root, root.path)
 
 
=== modified file 'src/provisioningserver/tests/test_upgrade_cluster.py'
--- src/provisioningserver/tests/test_upgrade_cluster.py	2015-03-25 15:33:23 +0000
+++ src/provisioningserver/tests/test_upgrade_cluster.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -27,11 +27,13 @@
 from maastesting.testcase import MAASTestCase
 from maastesting.utils import sample_binary_data
 from mock import Mock
-from provisioningserver import (
-    config,
-    upgrade_cluster,
-)
+from provisioningserver import upgrade_cluster
 from provisioningserver.boot.tftppath import list_subdirs
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.utils.fs import read_text_file
 from testtools.matchers import (
     DirExists,
@@ -86,9 +88,14 @@
 class TestMakeMAASOwnBootResources(MAASTestCase):
     """Tests for the `make_maas_own_boot_resources` upgrade."""
 
+    def setUp(self):
+        super(TestMakeMAASOwnBootResources, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
+
     def configure_storage(self, storage_dir):
         """Create a storage config."""
-        self.patch(config, 'BOOT_RESOURCES_STORAGE', storage_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage, storage_dir)
 
     def test__calls_chown_if_boot_resources_dir_exists(self):
         self.patch(upgrade_cluster, 'check_call')
@@ -102,7 +109,9 @@
     def test__skips_chown_if_boot_resources_dir_does_not_exist(self):
         self.patch(upgrade_cluster, 'check_call')
         storage_dir = os.path.join(self.make_dir(), factory.make_name('none'))
+        os.mkdir(storage_dir)
         self.configure_storage(storage_dir)
+        os.rmdir(storage_dir)
         upgrade_cluster.make_maas_own_boot_resources()
         self.assertThat(upgrade_cluster.check_call, MockNotCalled())
 
@@ -203,12 +212,18 @@
 class TestMigrateArchitecturesIntoUbuntuDirectory(MAASTestCase):
     """Tests for the `migrate_architectures_into_ubuntu_directory` upgrade."""
 
+    def setUp(self):
+        super(TestMigrateArchitecturesIntoUbuntuDirectory, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
+
     def configure_storage(self, storage_dir, make_current_dir=True):
         """Create a storage config."""
-        if make_current_dir:
-            current_dir = os.path.join(storage_dir, "current")
-            os.mkdir(current_dir)
-        self.patch(config, 'BOOT_RESOURCES_STORAGE', storage_dir)
+        current_dir = os.path.join(storage_dir, "current")
+        os.makedirs(current_dir)
+        set_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage, current_dir)
+        if not make_current_dir:
+            os.rmdir(current_dir)
 
     def test__list_subdirs_under_current_directory(self):
         self.patch(upgrade_cluster, 'list_subdirs').return_value = ['ubuntu']
 
=== modified file 'src/provisioningserver/upgrade_cluster.py'
--- src/provisioningserver/upgrade_cluster.py	2015-03-26 00:12:12 +0000
+++ src/provisioningserver/upgrade_cluster.py	2015-05-04 14:27:25 +0000
@@ -22,7 +22,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -30,7 +30,7 @@
 __all__ = [
     'add_arguments',
     'run',
-    ]
+]
 
 import os
 from os import makedirs
@@ -38,12 +38,15 @@
 from subprocess import check_call
 from textwrap import dedent
 
-from provisioningserver import config
 from provisioningserver.auth import get_maas_user_gpghome
 from provisioningserver.boot.tftppath import (
     drill_down,
     list_subdirs,
 )
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    get_config_cluster_variable,
+)
 from provisioningserver.import_images.boot_resources import (
     update_targets_conf,
     write_targets_conf,
@@ -57,8 +60,10 @@
 def make_maas_own_boot_resources():
     """Upgrade hook: make the `maas` user the owner of the boot resources."""
     # This reduces the privileges required for importing and managing images.
-    if os.path.isdir(config.BOOT_RESOURCES_STORAGE):
-        check_call(['chown', '-R', 'maas', config.BOOT_RESOURCES_STORAGE])
+    boot_resources_storage = get_config_cluster_variable(
+        CLUSTER_CONFIG.DB_boot_resources_storage)
+    if os.path.isdir(boot_resources_storage):
+        check_call(['chown', '-R', 'maas', boot_resources_storage])
 
 
 def create_gnupg_home():
@@ -146,8 +151,8 @@
     """Remove paths that contain directories with more levels. We don't want
     to move other operating systems under the ubuntu directory."""
     for arch, subarch, release, label in paths:
-        path = os.path.join(
-            config.BOOT_RESOURCES_STORAGE, 'current',
+        path = os.path.join(get_config_cluster_variable(
+            CLUSTER_CONFIG.DB_boot_resources_storage),
             arch, subarch, release, label)
         if len(list_subdirs(path)) == 0:
             yield (arch, subarch, release, label)
@@ -165,7 +170,8 @@
     folders have structure arch/subarch/release/label and move them into
     ubuntu folder. Making the final path ubuntu/arch/subarch/release/label.
     """
-    current_dir = os.path.join(config.BOOT_RESOURCES_STORAGE, "current")
+    current_dir = get_config_cluster_variable(
+        CLUSTER_CONFIG.DB_boot_resources_storage)
     if not os.path.isdir(current_dir):
         return
     # If ubuntu folder already exists, then no reason to continue
@@ -213,7 +219,7 @@
     create_gnupg_home,
     retire_bootresources_yaml,
     migrate_architectures_into_ubuntu_directory,
-    ]
+]
 
 
 def add_arguments(parser):
 
=== modified file 'src/provisioningserver/utils/__init__.py'
--- src/provisioningserver/utils/__init__.py	2015-03-30 18:05:57 +0000
+++ src/provisioningserver/utils/__init__.py	2015-05-04 14:27:25 +0000
@@ -97,7 +97,7 @@
     """
     # Avoid circular dependencies.
     from provisioningserver.rpc.region import CreateNode
-    from provisioningserver.cluster_config import get_cluster_uuid
+    from provisioningserver import cluster_config
 
     for elapsed, remaining, wait in retries(15, 5, reactor):
         try:
@@ -116,7 +116,8 @@
     try:
         response = yield client(
             CreateNode,
-            cluster_uuid=get_cluster_uuid(),
+            cluster_uuid=cluster_config.get_config_cluster_variable(
+                cluster_config.CLUSTER_CONFIG.DB_cluster_uuid),
             architecture=arch,
             power_type=power_type,
             power_parameters=json.dumps(power_parameters),
 
=== modified file 'src/provisioningserver/utils/script.py'
--- src/provisioningserver/utils/script.py	2015-02-24 13:52:12 +0000
+++ src/provisioningserver/utils/script.py	2015-05-04 14:27:25 +0000
@@ -7,7 +7,7 @@
     absolute_import,
     print_function,
     unicode_literals,
-    )
+)
 
 str = None
 
@@ -16,7 +16,7 @@
     'ActionScript',
     'AtomicWriteScript',
     'MainScript',
-    ]
+]
 
 from argparse import ArgumentParser
 from os import fdopen
@@ -24,6 +24,7 @@
 from subprocess import CalledProcessError
 import sys
 
+from provisioningserver.config import ClusterConfiguration
 from provisioningserver.utils.fs import atomic_write
 
 
@@ -92,20 +93,18 @@
 
     The `--config-file` option defaults to the value of
     `MAAS_PROVISIONING_SETTINGS` in the process's environment, or absent
-    that, `$MAAS_CONFIG_DIR/pserv.yaml` (normally /etc/maas/pserv.yaml for
-    packaged installations, or when running from branch, the equivalent
+    that, or when running from branch, the equivalent
     inside that branch).
     """
 
     def __init__(self, description):
         # Avoid circular imports.
-        from provisioningserver.config import Config
 
         super(MainScript, self).__init__(description)
         self.parser.add_argument(
             "-c", "--config-file", metavar="FILENAME",
             help="Configuration file to load [%(default)s].",
-            default=Config.DEFAULT_FILENAME)
+            default=ClusterConfiguration.default)
 
 
 class AtomicWriteScript:
@@ -141,7 +140,7 @@
         if args.mode is not None:
             mode = int(args.mode, 8)
         else:
-            mode = 0600
+            mode = 0o600
         atomic_write(
             content, args.filename, overwrite=not args.no_overwrite,
             mode=mode)
 
=== modified file 'src/provisioningserver/utils/tests/test_utils.py'
--- src/provisioningserver/utils/tests/test_utils.py	2015-03-30 18:05:57 +0000
+++ src/provisioningserver/utils/tests/test_utils.py	2015-05-04 14:27:25 +0000
@@ -34,12 +34,17 @@
     sentinel,
 )
 import provisioningserver
+from provisioningserver.cluster_config import (
+    CLUSTER_CONFIG,
+    set_config_cluster_variable,
+)
 from provisioningserver.rpc import region
 from provisioningserver.rpc.exceptions import (
     CommissionNodeFailed,
     NodeAlreadyExists,
 )
 from provisioningserver.rpc.testing import MockLiveClusterToRegionRPCFixture
+from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.testing.testcase import PservTestCase
 import provisioningserver.utils
 from provisioningserver.utils import (
@@ -411,6 +416,10 @@
 
 class TestCreateNode(PservTestCase):
 
+    def setUp(self):
+        super(TestCreateNode, self).setUp()
+        self.useFixture(ClusterConfigurationFixture())
+
     run_tests_with = MAASTwistedRunTest.make_factory(timeout=5)
 
     def prepare_region_rpc(self):
@@ -438,14 +447,14 @@
             'power_control': None,
             'system_id': uuid
         }
-        get_cluster_uuid = self.patch(
-            provisioningserver.cluster_config, 'get_cluster_uuid')
-        get_cluster_uuid.return_value = 'cluster-' + factory.make_UUID()
+        test_uuid = factory.make_UUID()
+        set_config_cluster_variable(CLUSTER_CONFIG.DB_cluster_uuid, test_uuid)
+
         yield create_node(
             macs, arch, power_type, power_parameters, hostname=hostname)
         self.assertThat(
             protocol.CreateNode, MockCalledOnceWith(
-                protocol, cluster_uuid=get_cluster_uuid.return_value,
+                protocol, cluster_uuid=test_uuid,
                 architecture=arch, power_type=power_type,
                 power_parameters=json.dumps(power_parameters),
                 mac_addresses=macs, hostname=hostname))
@@ -483,9 +492,9 @@
         system_id = factory.make_name("system-id")
         protocol.CreateNode.return_value = defer.succeed(
             {"system_id": system_id})
-        get_cluster_uuid = self.patch(
-            provisioningserver.cluster_config, 'get_cluster_uuid')
-        get_cluster_uuid.return_value = 'cluster-' + factory.make_UUID()
+
+        test_uuid = factory.make_UUID()
+        set_config_cluster_variable(CLUSTER_CONFIG.DB_cluster_uuid, test_uuid)
 
         uuid = 'node-' + factory.make_UUID()
         arch = factory.make_name('architecture')
@@ -506,7 +515,7 @@
             macs_with_duplicate, arch, power_type, power_parameters)
         self.assertThat(
             protocol.CreateNode, MockCalledOnceWith(
-                protocol, cluster_uuid=get_cluster_uuid.return_value,
+                protocol, cluster_uuid=test_uuid,
                 architecture=arch, power_type=power_type,
                 power_parameters=json.dumps(power_parameters),
                 mac_addresses=macs, hostname=None))
@@ -517,9 +526,6 @@
         self.addCleanup((yield connecting))
         system_id = factory.make_name("system-id")
         maaslog = self.patch(provisioningserver.utils, 'maaslog')
-        get_cluster_uuid = self.patch(
-            provisioningserver.utils, 'get_cluster_uuid')
-        get_cluster_uuid.return_value = 'cluster-' + factory.make_UUID()
 
         uuid = 'node-' + factory.make_UUID()
         macs = sorted(factory.make_mac_address() for _ in range(3))