Merge lp:~lamont/maas/bug-1647703 into lp:maas/2.1

[LaMont Jones]

Update the websocket node when the domain name changes.

Update the websocket node when the domain name changes.

=== modified file 'HACKING.txt'
--- HACKING.txt	2016-03-28 13:54:47 +0000
+++ HACKING.txt	2016-12-07 15:50:52 +0000
@@ -138,8 +138,9 @@
 regiond.log. To enable logging of all exceptions even exceptions where MAAS
 will return the correct HTTP status code.::
 
-    $ sudo sed -i 's/DEBUG = False/DEBUG = True/g' /usr/share/maas/maas/settings.py
-    $ sudo service maas-regiond restart
+  $ sudo sed -i 's/DEBUG = False/DEBUG = True/g' \
+  >   /usr/lib/python3/dist-packages/maasserver/djangosettings/settings.py
+  $ sudo service maas-regiond restart
 
 Run regiond in foreground
 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -149,8 +150,10 @@
 placed a breakpoint into the code you want to inspect you can start the regiond
 process in the foreground.::
 
-    $ sudo service maas-regiond stop
-    $ sudo -u maas -H DJANGO_SETTINGS_MODULE=maas.settings PYTHONPATH=/usr/share/maas twistd3 --nodaemon --pidfile= maas-regiond
+  $ sudo service maas-regiond stop
+  $ sudo -u maas -H \
+  >   DJANGO_SETTINGS_MODULE=maasserver.djangosettings.settings \
+  >   twistd3 --nodaemon --pidfile= maas-regiond
 
 
 .. Note::
@@ -175,7 +178,8 @@
 Development MAAS server setup
 =============================
 
-Access to the database is configured in ``src/maas/development.py``.
+Access to the database is configured in
+``src/maasserver/djangosettings/development.py``.
 
 The ``Makefile`` or the test suite sets up a development database
 cluster inside your branch. It lives in the ``db`` directory, which
 
=== modified file 'Makefile'
--- Makefile	2016-10-17 06:38:56 +0000
+++ Makefile	2016-12-07 15:50:52 +0000
@@ -427,7 +427,8 @@
 	$(warning 'distclean' is deprecated; use 'clean')
 
 harness: bin/maas-region bin/database
-	$(dbrun) bin/maas-region shell --settings=maas.demo
+	$(dbrun) bin/maas-region shell \
+	  --settings=maasserver.djangosettings.demo
 
 dbharness: bin/database
 	bin/database --preserve shell
 
=== modified file 'buildout.cfg'
--- buildout.cfg	2016-10-12 15:26:17 +0000
+++ buildout.cfg	2016-12-07 15:50:52 +0000
@@ -104,7 +104,7 @@
   twistd.region=twisted.scripts.twistd:run
 initialization =
   ${common:initialization}
-  environ.setdefault("DJANGO_SETTINGS_MODULE", "maas.development")
+  environ.setdefault("DJANGO_SETTINGS_MODULE", "maasserver.djangosettings.development")
 scripts =
   maas-region
   twistd.region
@@ -129,7 +129,6 @@
     # "--with-resources",
     "--with-scenarios",
     "--with-select",
-    "--select-dir=src/maas",
     "--select-dir=src/maasserver",
     "--select-dir=src/metadataserver",
     "--cover-package=maas,maasserver,metadataserver",
@@ -294,7 +293,7 @@
   from os import environ
   environ.setdefault("MAAS_RACK_DEVELOP", "TRUE")
   environ.setdefault("MAAS_ROOT", "${buildout:directory}/run-e2e")
-  environ.setdefault("DJANGO_SETTINGS_MODULE", "maas.development")
+  environ.setdefault("DJANGO_SETTINGS_MODULE", "maasserver.djangosettings.development")
   environ.setdefault("DEV_DB_NAME", "test_maas_e2e")
   environ.setdefault("MAAS_PREVENT_MIGRATIONS", "1")
 
 
=== modified file 'docs/_templates/maas/static/css/main.css'
--- docs/_templates/maas/static/css/main.css	2014-06-09 16:25:19 +0000
+++ docs/_templates/maas/static/css/main.css	2016-12-07 15:50:52 +0000
@@ -73,3 +73,17 @@
   text-decoration: none;
   border-bottom: 1px solid #6D4100;
 }
+
+/*
+ * Custom CSS selectors for the API documentation page.
+ *
+ * Make subtitles for each API endpoint smaller, so they don't overwhelm
+ * the remainder of the documentation.
+ */
+div#maas-api div#operations h4 code.docutils {
+  font-size: 75%;
+}
+
+div#maas-api div#operations div.section h5 {
+  font-size: 90%;
+}
 
=== modified file 'docs/conf.py'
--- docs/conf.py	2016-03-28 13:54:47 +0000
+++ docs/conf.py	2016-12-07 15:50:52 +0000
@@ -24,7 +24,8 @@
 from pytz import UTC
 
 # Configure MAAS's settings.
-environ.setdefault("DJANGO_SETTINGS_MODULE", "maas.settings")
+environ.setdefault(
+    "DJANGO_SETTINGS_MODULE", "maasserver.djangosettings.settings")
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 
=== modified file 'docs/troubleshooting.rst'
--- docs/troubleshooting.rst	2014-09-10 16:20:31 +0000
+++ docs/troubleshooting.rst	2016-12-07 15:50:52 +0000
@@ -111,7 +111,7 @@
      always point at the local server.
   #. If you are still getting "404 - Page not found" errors, check that the MAAS
      web interface has been installed in the right place. There should be a file
-     present called /usr/share/maas/maas/urls.py
+     called ``urls.py`` in ``/usr/lib/python3/dist-packages/maasserver/djangosettings/``.
 
 Debugging ephemeral image
 =========================
 
=== modified file 'media/README'
--- media/README	2012-03-11 21:13:22 +0000
+++ media/README	2016-12-07 15:50:52 +0000
@@ -1,5 +1,5 @@
 This folder contains somewhat ephemeral things: subfolders serve as
-MEDIA_ROOT for maas.demo and maas.development environments. The
-media/demo directory should always exist and not be deleted, though
-its contents can be. The media/development directory should be created
-and destroyed by tests, as needed.
+MEDIA_ROOT for maasserver.djangosettings.demo and .development
+environments. The media/demo directory should always exist and not be
+deleted, though its contents can be. The media/development directory
+should be created and destroyed by tests, as needed.
 
=== modified file 'required-packages/dev'
--- required-packages/dev	2016-08-24 20:20:55 +0000
+++ required-packages/dev	2016-12-07 15:50:52 +0000
@@ -13,10 +13,10 @@
 libjs-jquery
 libjs-jquery-hotkeys
 libjs-yui3-full
+libnss-wrapper
 make
 nodejs-legacy
 npm
-python-pocket-lint
 python-bson
 python-crochet
 python-django
@@ -26,6 +26,7 @@
 python-lxml
 python-netaddr
 python-netifaces
+python-pocket-lint
 python-psycopg2
 python-simplejson
 python-tempita
 
=== modified file 'services/reloader/run'
--- services/reloader/run	2016-05-11 19:01:48 +0000
+++ services/reloader/run	2016-12-07 15:50:52 +0000
@@ -128,7 +128,7 @@
         exclude_filter=lambda path: (
             "/test/" in path or "/testing/" in path or "/." in path))
     wm.add_watch(
-        ["src/maas*", "src/meta*"], TRIGGER_EVENTS,
+        ["src/maasserver", "src/metadataserver"], TRIGGER_EVENTS,
         proc_fun=handle_maas_change, rec=True, auto_add=True, do_glob=True)
     wm.add_watch(
         ["src/prov*"], TRIGGER_EVENTS, proc_fun=handle_pserv_change,
 
=== modified file 'src/maascli/cli.py'
--- src/maascli/cli.py	2016-07-30 01:17:54 +0000
+++ src/maascli/cli.py	2016-12-07 15:50:52 +0000
@@ -189,8 +189,8 @@
     # Setup and the allowed django commands into the maascli.
     management = get_django_management()
     if management is not None and is_maasserver_available():
-        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "maas.settings")
-        sys.path.append('/usr/share/maas')
+        os.environ.setdefault(
+            "DJANGO_SETTINGS_MODULE", "maasserver.djangosettings.settings")
         load_regiond_commands(management, parser)
 
 
 
=== modified file 'src/maasserver/__init__.py'
--- src/maasserver/__init__.py	2016-10-20 14:45:06 +0000
+++ src/maasserver/__init__.py	2016-12-07 15:50:52 +0000
@@ -8,7 +8,7 @@
     'DefaultViewMeta',
     'is_master_process',
     'logger',
-    ]
+]
 
 import logging
 from os import environ
 
=== added file 'src/maasserver/api/chassis.py'
--- src/maasserver/api/chassis.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/api/chassis.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,78 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__all__ = [
+    "ChassiHandler",
+    "ChassisHandler",
+    ]
+
+from maasserver.api.nodes import (
+    NodeHandler,
+    NodesHandler,
+)
+from maasserver.enum import NODE_PERMISSION
+from maasserver.models.node import Chassis
+from piston3.utils import rc
+
+# Chassis fields exposed on the API.
+DISPLAYED_CHASSIS_FIELDS = (
+    'system_id',
+    'hostname',
+    'cpu_count',
+    'memory',
+    'chassis_type',
+    'node_type',
+    'node_type_name',
+    )
+
+
+class ChassiHandler(NodeHandler):
+    """Manage an individual chassis.
+
+    The chassis is identified by its system_id.
+    """
+    api_doc_section_name = "Chassis"
+
+    create = update = None
+    model = Chassis
+    fields = DISPLAYED_CHASSIS_FIELDS
+
+    @classmethod
+    def chassis_type(cls, chassis):
+        return chassis.power_type
+
+    def delete(self, request, system_id):
+        """Delete a specific Chassis.
+
+        Returns 404 if the chassis is not found.
+        Returns 403 if the user does not have permission to delete the chassis.
+        Returns 204 if the chassis is successfully deleted.
+        """
+        chassis = self.model.objects.get_node_or_404(
+            system_id=system_id, user=request.user,
+            perm=NODE_PERMISSION.ADMIN)
+        chassis.delete()
+        return rc.DELETED
+
+    @classmethod
+    def resource_uri(cls, chassis=None):
+        # This method is called by piston in two different contexts:
+        # - when generating an uri template to be used in the documentation
+        # (in this case, it is called with node=None).
+        # - when populating the 'resource_uri' field of an object
+        # returned by the API (in this case, node is a node object).
+        chassis_system_id = "system_id"
+        if chassis is not None:
+            chassis_system_id = chassis.system_id
+        return ('chassi_handler', (chassis_system_id,))
+
+
+class ChassisHandler(NodesHandler):
+    """Manage the collection of all the chassis in the MAAS."""
+    api_doc_section_name = "Chassis"
+    create = update = delete = None
+    base_model = Chassis
+
+    @classmethod
+    def resource_uri(cls, *args, **kwargs):
+        return ('chassis_handler', [])
 
=== modified file 'src/maasserver/api/doc.py'
--- src/maasserver/api/doc.py	2016-04-12 22:25:44 +0000
+++ src/maasserver/api/doc.py	2016-12-07 15:50:52 +0000
@@ -33,7 +33,7 @@
 from piston3.doc import generate_doc
 from piston3.handler import BaseHandler
 from piston3.resource import Resource
-from provisioningserver.power.schema import JSON_POWER_TYPE_PARAMETERS
+from provisioningserver.drivers.power import PowerDriverRegistry
 
 
 def accumulate_api_resources(resolver, accumulator):
@@ -77,8 +77,7 @@
 def generate_power_types_doc():
     """Generate ReST documentation for the supported power types.
 
-    The documentation is derived from the `JSON_POWER_TYPE_PARAMETERS`
-    object.
+    The documentation is derived from the `PowerDriverRegistry`.
     """
     output = StringIO()
     line = partial(print, file=output)
@@ -92,14 +91,14 @@
          "list if the cluster in question is from an older version of "
          "MAAS.")
     line()
-    for item in JSON_POWER_TYPE_PARAMETERS:
-        title = "%s (%s)" % (item['name'], item['description'])
+    for _, driver in PowerDriverRegistry:
+        title = "%s (%s)" % (driver.name, driver.description)
         line(title)
         line('=' * len(title))
         line('')
         line("Power parameters:")
         line('')
-        for field in item['fields']:
+        for field in driver.settings:
             field_description = []
             field_description.append(
                 "* %s (%s)." % (field['name'], field['label']))
 
=== modified file 'src/maasserver/api/doc_handler.py'
--- src/maasserver/api/doc_handler.py	2016-08-18 17:31:05 +0000
+++ src/maasserver/api/doc_handler.py	2016-12-07 15:50:52 +0000
@@ -9,7 +9,7 @@
 
 
 API versions
-------------
+````````````
 
 At any given time, MAAS may support multiple versions of its API.  The version
 number is included in the API's URL, e.g. /api/2.0/
@@ -23,7 +23,7 @@
 
 
 HTTP methods and parameter-passing
-----------------------------------
+``````````````````````````````````
 
 The following HTTP methods are available for accessing the API:
  * GET (for information retrieval and queries),
@@ -82,6 +82,7 @@
 # etc. whatever render_api_docs() produces, so that you can concatenate
 # the two.
 api_doc_title = dedent("""
+    :tocdepth: 3
     .. _region-controller-api:
 
     ========
@@ -109,7 +110,7 @@
     line()
     line()
     line('Operations')
-    line('----------')
+    line('``````````')
     line()
 
     def export_key(export):
@@ -132,25 +133,24 @@
         section_name = doc.handler.api_doc_section_name
         line(section_name)
         line('=' * len(section_name))
-        line(doc.handler.__doc__.strip())
+        line(dedent(doc.handler.__doc__).strip())
         line()
         line()
         for (http_method, op), function in sorted(exports, key=export_key):
-            line("``%s %s``" % (http_method, uri_template), end="")
-            if op is not None:
-                line(" ``op=%s``" % op, end="")
+            operation = " op=%s" % op if op is not None else ""
+            subsection = "``%s %s%s``" % (http_method, uri_template, operation)
+            line("%s\n%s\n" % (subsection, '#' * len(subsection)))
             line()
             docstring = getdoc(function)
             if docstring is not None:
-                for docline in docstring.splitlines():
+                for docline in dedent(docstring).splitlines():
                     if docline.strip() == '':
                         # Blank line.  Don't indent.
                         line()
                     else:
                         # Print documentation line, indented.
-                        line("  ", docline, sep="")
+                        line(docline)
                 line()
-
     line()
     line()
     line(generate_power_types_doc())
 
=== modified file 'src/maasserver/api/interfaces.py'
--- src/maasserver/api/interfaces.py	2016-10-20 16:04:24 +0000
+++ src/maasserver/api/interfaces.py	2016-12-07 15:50:52 +0000
@@ -436,18 +436,18 @@
 
         Following are parameters specific to bonds:
 
-        :param bond-mode: The operating mode of the bond.
+        :param bond_mode: The operating mode of the bond.
             (Default: active-backup).
-        :param bond-miimon: The link monitoring freqeuncy in milliseconds.
+        :param bond_miimon: The link monitoring freqeuncy in milliseconds.
             (Default: 100).
-        :param bond-downdelay: Specifies the time, in milliseconds, to wait
+        :param bond_downdelay: Specifies the time, in milliseconds, to wait
             before disabling a slave after a link failure has been detected.
-        :param bond-updelay: Specifies the time, in milliseconds, to wait
+        :param bond_updelay: Specifies the time, in milliseconds, to wait
             before enabling a slave after a link recovery has been detected.
-        :param bond-lacp_rate: Option specifying the rate in which we'll ask
+        :param bond_lacp_rate: Option specifying the rate in which we'll ask
             our link partner to transmit LACPDU packets in 802.3ad mode.
             Available options are fast or slow. (Default: slow).
-        :param bond-xmit_hash_policy: The transmit hash policy to use for
+        :param bond_xmit_hash_policy: The transmit hash policy to use for
             slave selection in balance-xor, 802.3ad, and tlb modes.
 
         Supported bonding modes (bond-mode):
 
=== modified file 'src/maasserver/api/nodes.py'
--- src/maasserver/api/nodes.py	2016-06-17 07:16:39 +0000
+++ src/maasserver/api/nodes.py	2016-12-07 15:50:52 +0000
@@ -47,10 +47,9 @@
     Node,
     OwnerData,
 )
-from maasserver.models.node import typecast_to_node_type
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from piston3.utils import rc
-from provisioningserver.power.schema import UNKNOWN_POWER_TYPE
+from provisioningserver.drivers.power import UNKNOWN_POWER_TYPE
 
 
 def store_node_power_parameters(node, request):
@@ -171,7 +170,7 @@
         else:
             # Return the specific node type object so we get the correct
             # listing
-            return typecast_to_node_type(node)
+            return node.as_self()
 
     def delete(self, request, system_id):
         """Delete a specific Node.
@@ -183,7 +182,7 @@
         node = self.model.objects.get_node_or_404(
             system_id=system_id, user=request.user,
             perm=NODE_PERMISSION.ADMIN)
-        typecast_to_node_type(node).delete()
+        node.as_self().delete()
         return rc.DELETED
 
     @classmethod
@@ -315,19 +314,23 @@
 
         if self.base_model == Node:
             # Avoid circular dependencies
+            from maasserver.api.chassis import ChassisHandler
             from maasserver.api.devices import DevicesHandler
             from maasserver.api.machines import MachinesHandler
             from maasserver.api.rackcontrollers import RackControllersHandler
             from maasserver.api.regioncontrollers import (
                 RegionControllersHandler
             )
+            from maasserver.api.storage import StoragesHandler
             racks = RackControllersHandler().read(request).order_by("id")
             nodes = list(chain(
+                ChassisHandler().read(request).order_by("id"),
                 DevicesHandler().read(request).order_by("id"),
                 MachinesHandler().read(request).order_by("id"),
                 racks,
                 RegionControllersHandler().read(request).exclude(
                     id__in=racks).order_by("id"),
+                StoragesHandler().read(request).order_by("id"),
             ))
             return nodes
         else:
 
=== modified file 'src/maasserver/api/results.py'
--- src/maasserver/api/results.py	2016-07-30 01:17:54 +0000
+++ src/maasserver/api/results.py	2016-12-07 15:50:52 +0000
@@ -14,7 +14,6 @@
 )
 from maasserver.enum import NODE_PERMISSION
 from maasserver.models import Node
-from maasserver.models.node import typecast_to_node_type
 from metadataserver.models import NodeResult
 
 
@@ -54,9 +53,9 @@
         if result_type is not None:
             results = results.filter(result_type__in=result_type)
         # Convert the node objects into typed node objects so we get the
-        # proper listing
+        # proper listing.
         for result in results:
-            result.node = typecast_to_node_type(result.node)
+            result.node = result.node.as_self()
         return results
 
     @classmethod
 
=== added file 'src/maasserver/api/storage.py'
--- src/maasserver/api/storage.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/api/storage.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,76 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__all__ = [
+    "StorageHandler",
+    "StoragesHandler",
+    ]
+
+from maasserver.api.nodes import (
+    NodeHandler,
+    NodesHandler,
+)
+from maasserver.enum import NODE_PERMISSION
+from maasserver.models.node import Storage
+from piston3.utils import rc
+
+# Storage fields exposed on the API.
+DISPLAYED_STORAGE_FIELDS = (
+    'system_id',
+    'hostname',
+    'storage_type',
+    'node_type',
+    'node_type_name',
+    )
+
+
+class StorageHandler(NodeHandler):
+    """Manage an individual storage system.
+
+    The storage is identified by its system_id.
+    """
+    api_doc_section_name = "Storage"
+
+    create = update = None
+    model = Storage
+    fields = DISPLAYED_STORAGE_FIELDS
+
+    @classmethod
+    def storage_type(cls, storage):
+        return storage.power_type
+
+    def delete(self, request, system_id):
+        """Delete a specific Storage.
+
+        Returns 404 if the storage is not found.
+        Returns 403 if the user does not have permission to delete the storage.
+        Returns 204 if the storage is successfully deleted.
+        """
+        storage = self.model.objects.get_node_or_404(
+            system_id=system_id, user=request.user,
+            perm=NODE_PERMISSION.ADMIN)
+        storage.delete()
+        return rc.DELETED
+
+    @classmethod
+    def resource_uri(cls, storage=None):
+        # This method is called by piston in two different contexts:
+        # - when generating an uri template to be used in the documentation
+        # (in this case, it is called with node=None).
+        # - when populating the 'resource_uri' field of an object
+        # returned by the API (in this case, node is a node object).
+        storage_system_id = "system_id"
+        if storage is not None:
+            storage_system_id = storage.system_id
+        return ('storage_handler', (storage_system_id,))
+
+
+class StoragesHandler(NodesHandler):
+    """Manage the collection of all the storage in the MAAS."""
+    api_doc_section_name = "Storages"
+    create = update = delete = None
+    base_model = Storage
+
+    @classmethod
+    def resource_uri(cls, *args, **kwargs):
+        return ('storages_handler', [])
 
=== modified file 'src/maasserver/api/subnets.py'
--- src/maasserver/api/subnets.py	2016-09-23 01:32:02 +0000
+++ src/maasserver/api/subnets.py	2016-12-07 15:50:52 +0000
@@ -29,6 +29,7 @@
     'rdns_mode',
     'active_discovery',
     'allow_proxy',
+    'managed',
 )
 
 
@@ -49,32 +50,76 @@
 
     @admin_method
     def create(self, request):
-        """Create a subnet.
-
-        :param name: Name of the subnet.
-        :param description: Description of the subnet.
-        :param fabric: Fabric for the subnet. Defaults to the fabric the
-            provided VLAN belongs to or defaults to the default fabric.
-        :param vlan: VLAN this subnet belongs to. Defaults to the default
-            VLAN for the provided fabric or defaults to the default VLAN in
-            the default fabric.
-        :param vid: VID of the VLAN this subnet belongs to. Only used when
-            vlan is not provided. Picks the VLAN with this VID in the provided
-            fabric or the default fabric if one is not given.
-        :param space: Space this subnet is in. Defaults to the default space.
-        :param cidr: The network CIDR for this subnet.
-        :param gateway_ip: The gateway IP address for this subnet.
-        :param rdns_mode: How reverse DNS is handled for this subnet.
-            One of: 0 (Disabled), 1 (Enabled), or 2 (RFC2317).  Disabled means
-            no reverse zone is created; Enabled means generate the reverse
-            zone; RFC2317 extends Enabled to create the necessary parent zone
-            with the appropriate CNAME resource records for the network, if the
-            network is small enough to require the support described in
-            RFC2317.
-        :param allow_proxy: Configure maas-proxy to allow requests from this
-            subnet.
-        :param dns_servers: Comma-seperated list of DNS servers for this
-            subnet.
+        """\
+        Create a subnet.
+
+        Required parameters
+        -------------------
+
+        cidr
+          The network CIDR for this subnet.
+
+
+        Optional parameters
+        -------------------
+
+        name
+          Name of the subnet.
+
+        description
+          Description of the subnet.
+
+        vlan
+          VLAN this subnet belongs to. Defaults to the default VLAN for the
+          provided fabric or defaults to the default VLAN in the default fabric
+          (if unspecified).
+
+        fabric
+          Fabric for the subnet. Defaults to the fabric the
+          provided VLAN belongs to, or defaults to the default fabric.
+
+        vid
+          VID of the VLAN this subnet belongs to. Only used when vlan is
+          not provided. Picks the VLAN with this VID in the provided
+          fabric or the default fabric if one is not given.
+
+        space
+          Space this subnet is in. Defaults to the default space.
+
+        gateway_ip
+          The gateway IP address for this subnet.
+
+        rdns_mode
+          How reverse DNS is handled for this subnet.
+          One of: 0 (Disabled), 1 (Enabled), or 2 (RFC2317).  Disabled
+          means no reverse zone is created; Enabled means generate the
+          reverse zone; RFC2317 extends Enabled to create the necessary
+          parent zone with the appropriate CNAME resource records for the
+          network, if the network is small enough to require the support
+          described in RFC2317.
+
+        allow_proxy
+          Configure maas-proxy to allow requests from this
+          subnet.
+
+        dns_servers
+          Comma-seperated list of DNS servers for this subnet.
+
+        managed
+          In MAAS 2.0+, all subnets are assumed to be managed by default.
+
+          Only managed subnets allow DHCP to be enabled on their related
+          dynamic ranges. (Thus, dynamic ranges become "informational
+          only"; an indication that another DHCP server is currently
+          handling them, or that MAAS will handle them when the subnet is
+          enabled for management.)
+
+          Managed subnets do not allow IP allocation by default. The
+          meaning of a "reserved" IP range is reversed for an unmanaged
+          subnet. (That is, for managed subnets, "reserved" means "MAAS
+          cannot allocate any IP address within this reserved block". For
+          unmanaged subnets, "reserved" means "MAAS must allocate IP
+          addresses only from reserved IP ranges".
         """
         form = SubnetForm(data=request.data)
         if form.is_valid():
@@ -100,7 +145,8 @@
 
     @classmethod
     def space(cls, subnet):
-        """Return the name of the space.
+        """\
+        Return the name of the space.
 
         Only the name is returned because the space endpoint will return
         a list of all subnets in that space. If this returned the subnet
@@ -109,7 +155,8 @@
         return subnet.space.get_name()
 
     def read(self, request, subnet_id):
-        """Read subnet.
+        """\
+        Read subnet.
 
         Returns 404 if the subnet is not found.
         """
@@ -117,19 +164,44 @@
             subnet_id, request.user, NODE_PERMISSION.VIEW)
 
     def update(self, request, subnet_id):
-        """Update subnet.
-
-        :param name: Name of the subnet.
-        :param description: Description of the subnet.
-        :param vlan: VLAN this subnet belongs to.
-        :param space: Space this subnet is in.
-        :param cidr: The network CIDR for this subnet.
-        :param gateway_ip: The gateway IP address for this subnet.
-        :param rdns_mode: How reverse DNS is handled for this subnet.
-        :param allow_proxy: Configure maas-proxy to allow requests from this \
-            subnet.
-        :param dns_servers: Comma-seperated list of DNS servers for this \
-            subnet.
+        """\
+        Update the specified subnet.
+
+        Please see the documentation for the 'create' operation for detailed
+        descriptions of each parameter.
+
+        Optional parameters
+        -------------------
+
+        name
+          Name of the subnet.
+
+        description
+          Description of the subnet.
+
+        vlan
+          VLAN this subnet belongs to.
+
+        space
+          Space this subnet is in.
+
+        cidr
+          The network CIDR for this subnet.
+
+        gateway_ip
+          The gateway IP address for this subnet.
+
+        rdns_mode
+          How reverse DNS is handled for this subnet.
+
+        allow_proxy
+          Configure maas-proxy to allow requests from this subnet.
+
+        dns_servers
+          Comma-seperated list of DNS servers for this subnet.
+
+        managed
+          If False, MAAS should not manage this subnet. (Default: True)
 
         Returns 404 if the subnet is not found.
         """
@@ -142,7 +214,8 @@
             raise MAASAPIValidationError(form.errors)
 
     def delete(self, request, subnet_id):
-        """Delete subnet.
+        """\
+        Delete subnet.
 
         Returns 404 if the subnet is not found.
         """
@@ -153,7 +226,8 @@
 
     @operation(idempotent=True)
     def reserved_ip_ranges(self, request, subnet_id):
-        """Lists IP ranges currently reserved in the subnet.
+        """\
+        Lists IP ranges currently reserved in the subnet.
 
         Returns 404 if the subnet is not found.
         """
@@ -163,7 +237,8 @@
 
     @operation(idempotent=True)
     def unreserved_ip_ranges(self, request, subnet_id):
-        """Lists IP ranges currently unreserved in the subnet.
+        """\
+        Lists IP ranges currently unreserved in the subnet.
 
         Returns 404 if the subnet is not found.
         """
@@ -174,22 +249,27 @@
 
     @operation(idempotent=True)
     def statistics(self, request, subnet_id):
-        """
+        """\
         Returns statistics for the specified subnet, including:
 
-        num_available - the number of available IP addresses
-        largest_available - the largest number of contiguous free IP addresses
-        num_unavailable - the number of unavailable IP addresses
-        total_addresses - the sum of the available plus unavailable addresses
-        usage - the (floating point) usage percentage of this subnet
-        usage_string - the (formatted unicode) usage percentage of this subnet
-        ranges - the specific IP ranges present in ths subnet (if specified)
-
-        Optional arguments:
-        include_ranges: if True, includes detailed information
-        about the usage of this range.
-        include_suggestions: if True, includes the suggested gateway and
-        dynamic range for this subnet, if it were to be configured.
+        num_available: the number of available IP addresses
+        largest_available: the largest number of contiguous free IP addresses
+        num_unavailable: the number of unavailable IP addresses
+        total_addresses: the sum of the available plus unavailable addresses
+        usage: the (floating point) usage percentage of this subnet
+        usage_string: the (formatted unicode) usage percentage of this subnet
+        ranges: the specific IP ranges present in ths subnet (if specified)
+
+        Optional parameters
+        -------------------
+
+        include_ranges
+           If True, includes detailed information
+           about the usage of this range.
+
+        include_suggestions
+          If True, includes the suggested gateway and dynamic range for this
+          subnet, if it were to be configured.
 
         Returns 404 if the subnet is not found.
         """
@@ -208,14 +288,19 @@
 
     @operation(idempotent=True)
     def ip_addresses(self, request, subnet_id):
-        """
+        """\
         Returns a summary of IP addresses assigned to this subnet.
 
-        Optional arguments:
-        with_username: (default=True) if False, suppresses the display
-        of usernames associated with each address.
-        with_node_summary: (default=True) if False, suppresses the display
-        of any node associated with each address.
+        Optional parameters
+        -------------------
+
+        with_username
+          If False, suppresses the display of usernames associated with each
+          address. (Default: True)
+
+        with_node_summary
+          If False, suppresses the display of any node associated with each
+          address. (Default: True)
         """
         subnet = Subnet.objects.get_subnet_or_404(
             subnet_id, request.user, NODE_PERMISSION.VIEW)
 
=== modified file 'src/maasserver/api/tags.py'
--- src/maasserver/api/tags.py	2016-04-27 00:55:47 +0000
+++ src/maasserver/api/tags.py	2016-12-07 15:50:52 +0000
@@ -37,7 +37,6 @@
     RegionController,
     Tag,
 )
-from maasserver.models.node import typecast_to_node_type
 from maasserver.models.user import get_auth_tokens
 from maasserver.utils.orm import get_one
 from piston3.utils import rc
@@ -137,7 +136,7 @@
         self.fields = None
         tag = Tag.objects.get_tag_or_404(name=name, user=request.user)
         return [
-            typecast_to_node_type(node)
+            node.as_self()
             for node in model.objects.get_nodes(
                 request.user, NODE_PERMISSION.VIEW,
                 from_nodes=tag.node_set.all())
 
=== added file 'src/maasserver/api/tests/test_chassis.py'
--- src/maasserver/api/tests/test_chassis.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/api/tests/test_chassis.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,127 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for chassis API."""
+
+__all__ = []
+
+import http.client
+
+from django.core.urlresolvers import reverse
+from maasserver.enum import (
+    NODE_STATUS,
+    NODE_TYPE,
+)
+from maasserver.testing.api import APITestCase
+from maasserver.testing.factory import factory
+from maasserver.utils.converters import json_load_bytes
+from maasserver.utils.orm import reload_object
+
+
+class TestChassisAPI(APITestCase.ForUser):
+
+    def test_handler_path(self):
+        self.assertEqual(
+            '/api/2.0/chassis/', reverse('chassis_handler'))
+
+    def create_chassis(self, owner, nb=3):
+        return [
+            factory.make_Node(
+                interface=True, node_type=NODE_TYPE.CHASSIS, owner=owner)
+            for _ in range(nb)
+        ]
+
+    def test_read_lists_chassis(self):
+        # The api allows for fetching the list of chassis.
+        chassis = self.create_chassis(owner=self.user)
+        factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        response = self.client.get(reverse('chassis_handler'))
+        parsed_result = json_load_bytes(response.content)
+
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [chassi.system_id for chassi in chassis],
+            [chassi.get('system_id') for chassi in parsed_result])
+
+    def test_read_ignores_nodes(self):
+        factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        response = self.client.get(reverse('chassis_handler'))
+        parsed_result = json_load_bytes(response.content)
+
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertEqual(
+            [],
+            [chassi.get('system_id') for chassi in parsed_result])
+
+    def test_read_with_id_returns_matching_chassis(self):
+        # The "list" operation takes optional "id" parameters.  Only
+        # chassis with matching ids will be returned.
+        chassis = self.create_chassis(owner=self.user)
+        ids = [chassi.system_id for chassi in chassis]
+        matching_id = ids[0]
+        response = self.client.get(reverse('chassis_handler'), {
+            'id': [matching_id],
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertItemsEqual(
+            [matching_id],
+            [chassi.get('system_id') for chassi in parsed_result])
+
+    def test_read_returns_limited_fields(self):
+        self.create_chassis(owner=self.user)
+        response = self.client.get(reverse('chassis_handler'))
+        parsed_result = json_load_bytes(response.content)
+        self.assertItemsEqual(
+            [
+                'hostname',
+                'system_id',
+                'cpu_count',
+                'memory',
+                'chassis_type',
+                'node_type',
+                'node_type_name',
+                'resource_uri',
+            ],
+            list(parsed_result[0]))
+
+
+def get_chassi_uri(chassis):
+    """Return a chassis URI on the API."""
+    return reverse('chassi_handler', args=[chassis.system_id])
+
+
+class TestChassiAPI(APITestCase.ForUser):
+
+    def test_handler_path(self):
+        system_id = factory.make_name('system-id')
+        self.assertEqual(
+            '/api/2.0/chassis/%s/' % system_id,
+            reverse('chassi_handler', args=[system_id]))
+
+    def test_GET_reads_chassis(self):
+        chassis = factory.make_Node(
+            node_type=NODE_TYPE.CHASSIS, owner=self.user)
+
+        response = self.client.get(get_chassi_uri(chassis))
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        parsed_chassis = json_load_bytes(response.content)
+        self.assertEqual(chassis.system_id, parsed_chassis["system_id"])
+
+    def test_DELETE_removes_chassis(self):
+        self.become_admin()
+        chassis = factory.make_Node(
+            node_type=NODE_TYPE.CHASSIS, owner=self.user)
+        response = self.client.delete(get_chassi_uri(chassis))
+        self.assertEqual(
+            http.client.NO_CONTENT, response.status_code, response.content)
+        self.assertIsNone(reload_object(chassis))
+
+    def test_DELETE_rejects_deletion_if_not_permitted(self):
+        chassis = factory.make_Node(
+            node_type=NODE_TYPE.CHASSIS, owner=factory.make_User())
+        response = self.client.delete(get_chassi_uri(chassis))
+        self.assertEqual(http.client.FORBIDDEN, response.status_code)
+        self.assertEqual(chassis, reload_object(chassis))
 
=== modified file 'src/maasserver/api/tests/test_doc.py'
--- src/maasserver/api/tests/test_doc.py	2016-08-31 13:52:59 +0000
+++ src/maasserver/api/tests/test_doc.py	2016-12-07 15:50:52 +0000
@@ -8,6 +8,7 @@
 import http.client
 from inspect import getdoc
 from io import StringIO
+import random
 import sys
 import types
 from unittest.mock import sentinel
@@ -49,7 +50,7 @@
 from piston3.doc import HandlerDocumentation
 from piston3.handler import BaseHandler
 from piston3.resource import Resource
-from provisioningserver.power.schema import make_json_field
+from provisioningserver.drivers.power import PowerDriverRegistry
 from testtools.matchers import (
     AfterPreprocessing,
     AllMatch,
@@ -416,22 +417,19 @@
         self.assertThat(doc, ContainsAll(["Power types", "IPMI"]))
 
     def test__generate_power_types_doc_generates_describes_power_type(self):
-        name = factory.make_name('name')
-        description = factory.make_name('description')
-        param_name = factory.make_name('param_name')
-        param_description = factory.make_name('param_description')
-        json_fields = [{
-            'name': name,
-            'description': description,
-            'fields': [
-                make_json_field(param_name, param_description),
-            ],
-        }]
-        self.patch(doc_module, "JSON_POWER_TYPE_PARAMETERS", json_fields)
+        power_driver = random.choice([
+            driver
+            for _, driver in PowerDriverRegistry
+            if len(driver.settings) > 0
+        ])
         doc = generate_power_types_doc()
         self.assertThat(
             doc,
-            ContainsAll([name, description, param_name, param_description]))
+            ContainsAll([
+                power_driver.name,
+                power_driver.description,
+                power_driver.settings[0]['name'],
+                power_driver.settings[0]['label']]))
 
 
 class TestDescribeCanonical(MAASTestCase):
 
=== modified file 'src/maasserver/api/tests/test_nodes.py'
--- src/maasserver/api/tests/test_nodes.py	2016-10-28 08:43:09 +0000
+++ src/maasserver/api/tests/test_nodes.py	2016-12-07 15:50:52 +0000
@@ -304,7 +304,6 @@
         response = self.client.get(reverse('nodes_handler'))
         parsed_result = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET))
-
         self.assertEqual(http.client.OK, response.status_code)
         self.assertItemsEqual(system_ids, extract_system_ids(parsed_result))
 
 
=== added file 'src/maasserver/api/tests/test_storage.py'
--- src/maasserver/api/tests/test_storage.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/api/tests/test_storage.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,125 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for storage API."""
+
+__all__ = []
+
+import http.client
+
+from django.core.urlresolvers import reverse
+from maasserver.enum import (
+    NODE_STATUS,
+    NODE_TYPE,
+)
+from maasserver.testing.api import APITestCase
+from maasserver.testing.factory import factory
+from maasserver.utils.converters import json_load_bytes
+from maasserver.utils.orm import reload_object
+
+
+class TestStoragesAPI(APITestCase.ForUser):
+
+    def test_handler_path(self):
+        self.assertEqual(
+            '/api/2.0/storages/', reverse('storages_handler'))
+
+    def create_storages(self, owner, nb=3):
+        return [
+            factory.make_Node(
+                interface=True, node_type=NODE_TYPE.STORAGE, owner=owner)
+            for _ in range(nb)
+        ]
+
+    def test_read_lists_storage(self):
+        # The api allows for fetching the list of storages.
+        storages = self.create_storages(owner=self.user)
+        factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        response = self.client.get(reverse('storages_handler'))
+        parsed_result = json_load_bytes(response.content)
+
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [storage.system_id for storage in storages],
+            [storage.get('system_id') for storage in parsed_result])
+
+    def test_read_ignores_nodes(self):
+        factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        response = self.client.get(reverse('storages_handler'))
+        parsed_result = json_load_bytes(response.content)
+
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertEqual(
+            [],
+            [storage.get('system_id') for storage in parsed_result])
+
+    def test_read_with_id_returns_matching_storage(self):
+        # The "list" operation takes optional "id" parameters.  Only
+        # storages with matching ids will be returned.
+        storages = self.create_storages(owner=self.user)
+        ids = [storage.system_id for storage in storages]
+        matching_id = ids[0]
+        response = self.client.get(reverse('storages_handler'), {
+            'id': [matching_id],
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertItemsEqual(
+            [matching_id],
+            [storage.get('system_id') for storage in parsed_result])
+
+    def test_read_returns_limited_fields(self):
+        self.create_storages(owner=self.user)
+        response = self.client.get(reverse('storages_handler'))
+        parsed_result = json_load_bytes(response.content)
+        self.assertItemsEqual(
+            [
+                'hostname',
+                'system_id',
+                'storage_type',
+                'node_type',
+                'node_type_name',
+                'resource_uri',
+            ],
+            list(parsed_result[0]))
+
+
+def get_storage_uri(storage):
+    """Return a storage's URI on the API."""
+    return reverse('storage_handler', args=[storage.system_id])
+
+
+class TestStorageAPI(APITestCase.ForUser):
+
+    def test_handler_path(self):
+        system_id = factory.make_name('system-id')
+        self.assertEqual(
+            '/api/2.0/storages/%s/' % system_id,
+            reverse('storage_handler', args=[system_id]))
+
+    def test_GET_reads_storage(self):
+        storage = factory.make_Node(
+            node_type=NODE_TYPE.STORAGE, owner=self.user)
+
+        response = self.client.get(get_storage_uri(storage))
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        parsed_storage = json_load_bytes(response.content)
+        self.assertEqual(storage.system_id, parsed_storage["system_id"])
+
+    def test_DELETE_removes_storage(self):
+        self.become_admin()
+        storage = factory.make_Node(
+            node_type=NODE_TYPE.STORAGE, owner=self.user)
+        response = self.client.delete(get_storage_uri(storage))
+        self.assertEqual(
+            http.client.NO_CONTENT, response.status_code, response.content)
+        self.assertIsNone(reload_object(storage))
+
+    def test_DELETE_rejects_deletion_if_not_permitted(self):
+        storage = factory.make_Node(
+            node_type=NODE_TYPE.STORAGE, owner=factory.make_User())
+        response = self.client.delete(get_storage_uri(storage))
+        self.assertEqual(http.client.FORBIDDEN, response.status_code)
+        self.assertEqual(storage, reload_object(storage))
 
=== modified file 'src/maasserver/api/tests/test_subnets.py'
--- src/maasserver/api/tests/test_subnets.py	2016-10-20 21:30:58 +0000
+++ src/maasserver/api/tests/test_subnets.py	2016-12-07 15:50:52 +0000
@@ -87,6 +87,7 @@
         rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
         allow_proxy = factory.pick_bool()
         gateway_ip = factory.pick_ip_in_network(network)
+        managed = factory.pick_bool()
         dns_servers = []
         for _ in range(2):
             dns_servers.append(
@@ -102,6 +103,7 @@
             "dns_servers": ','.join(dns_servers),
             "rdns_mode": rdns_mode,
             "allow_proxy": allow_proxy,
+            "managed": managed,
         })
         self.assertEqual(
             http.client.OK, response.status_code, response.content)
@@ -115,6 +117,7 @@
         self.assertEqual(dns_servers, created_subnet['dns_servers'])
         self.assertEqual(rdns_mode, created_subnet['rdns_mode'])
         self.assertEqual(allow_proxy, created_subnet['allow_proxy'])
+        self.assertEqual(managed, created_subnet['managed'])
 
     def test_create_defaults_to_allow_proxy(self):
         self.become_admin()
@@ -151,7 +154,43 @@
         self.assertEqual(gateway_ip, created_subnet['gateway_ip'])
         self.assertEqual(dns_servers, created_subnet['dns_servers'])
         self.assertEqual(rdns_mode, created_subnet['rdns_mode'])
-        self.assertEqual(True, created_subnet['allow_proxy'])
+
+    def test_create_defaults_to_managed(self):
+        self.become_admin()
+        subnet_name = factory.make_name("subnet")
+        vlan = factory.make_VLAN()
+        space = factory.make_Space()
+        network = factory.make_ip4_or_6_network()
+        cidr = str(network.cidr)
+        rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
+        gateway_ip = factory.pick_ip_in_network(network)
+        dns_servers = []
+        for _ in range(2):
+            dns_servers.append(
+                factory.pick_ip_in_network(
+                    network, but_not=[gateway_ip] + dns_servers))
+        uri = get_subnets_uri()
+        response = self.client.post(uri, {
+            "name": subnet_name,
+            "vlan": vlan.id,
+            "space": space.id,
+            "cidr": cidr,
+            "gateway_ip": gateway_ip,
+            "dns_servers": ','.join(dns_servers),
+            "rdns_mode": rdns_mode,
+        })
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        created_subnet = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(subnet_name, created_subnet['name'])
+        self.assertEqual(vlan.vid, created_subnet['vlan']['vid'])
+        self.assertEqual(space.get_name(), created_subnet['space'])
+        self.assertEqual(cidr, created_subnet['cidr'])
+        self.assertEqual(gateway_ip, created_subnet['gateway_ip'])
+        self.assertEqual(dns_servers, created_subnet['dns_servers'])
+        self.assertEqual(rdns_mode, created_subnet['rdns_mode'])
+        self.assertEqual(True, created_subnet['managed'])
 
     def test_create_admin_only(self):
         subnet_name = factory.make_name("subnet")
@@ -200,6 +239,7 @@
             "cidr": Equals(subnet.cidr),
             "gateway_ip": Equals(subnet.gateway_ip),
             "dns_servers": Equals(subnet.dns_servers),
+            "managed": Equals(subnet.managed),
             }))
 
     def test_read_404_when_bad_id(self):
@@ -232,20 +272,24 @@
         new_name = factory.make_name("subnet")
         new_rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
         new_allow_proxy = factory.pick_bool()
+        new_managed = factory.pick_bool()
         uri = get_subnet_uri(subnet)
         response = self.client.put(uri, {
             "name": new_name,
             "rdns_mode": new_rdns_mode,
             "allow_proxy": new_allow_proxy,
+            "managed": new_managed,
         })
         self.assertEqual(
             http.client.OK, response.status_code, response.content)
         self.assertEqual(
             new_name, json.loads(
                 response.content.decode(settings.DEFAULT_CHARSET))['name'])
-        self.assertEqual(new_name, reload_object(subnet).name)
-        self.assertEqual(new_rdns_mode, reload_object(subnet).rdns_mode)
-        self.assertEqual(new_allow_proxy, reload_object(subnet).allow_proxy)
+        subnet = reload_object(subnet)
+        self.assertEqual(new_name, subnet.name)
+        self.assertEqual(new_rdns_mode, subnet.rdns_mode)
+        self.assertEqual(new_allow_proxy, subnet.allow_proxy)
+        self.assertEqual(new_managed, subnet.managed)
 
     def test_update_admin_only(self):
         subnet = factory.make_Subnet()
 
=== modified file 'src/maasserver/api/tests/test_vlans.py'
--- src/maasserver/api/tests/test_vlans.py	2016-05-24 21:29:53 +0000
+++ src/maasserver/api/tests/test_vlans.py	2016-12-07 15:50:52 +0000
@@ -84,6 +84,29 @@
         self.assertEqual(vid, response_data['vid'])
         self.assertEqual(mtu, response_data['mtu'])
 
+    def test_create_with_relay_vlan(self):
+        self.become_admin()
+        fabric = factory.make_Fabric()
+        vlan_name = factory.make_name("fabric")
+        vid = random.randint(1, 1000)
+        mtu = random.randint(552, 1500)
+        relay_vlan = factory.make_VLAN()
+        uri = get_vlans_uri(fabric)
+        response = self.client.post(uri, {
+            "name": vlan_name,
+            "vid": vid,
+            "mtu": mtu,
+            "relay_vlan": relay_vlan.id,
+        })
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        response_data = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(vlan_name, response_data['name'])
+        self.assertEqual(vid, response_data['vid'])
+        self.assertEqual(mtu, response_data['mtu'])
+        self.assertEqual(relay_vlan.vid, response_data['relay_vlan']['vid'])
+
     def test_create_admin_only(self):
         fabric = factory.make_Fabric()
         vlan_name = factory.make_name("fabric")
@@ -182,6 +205,23 @@
         self.assertEqual(new_vid, parsed_vlan['vid'])
         self.assertEqual(new_vid, vlan.vid)
 
+    def test_update_sets_relay_vlan(self):
+        self.become_admin()
+        fabric = factory.make_Fabric()
+        vlan = factory.make_VLAN(fabric=fabric)
+        uri = get_vlan_uri(vlan)
+        relay_vlan = factory.make_VLAN()
+        response = self.client.put(uri, {
+            "relay_vlan": relay_vlan.id,
+        })
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        parsed_vlan = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        vlan = reload_object(vlan)
+        self.assertEqual(relay_vlan.vid, parsed_vlan['relay_vlan']['vid'])
+        self.assertEqual(relay_vlan, vlan.relay_vlan)
+
     def test_update_with_fabric(self):
         self.become_admin()
         fabric = factory.make_Fabric()
 
=== modified file 'src/maasserver/api/vlans.py'
--- src/maasserver/api/vlans.py	2016-04-27 20:40:24 +0000
+++ src/maasserver/api/vlans.py	2016-12-07 15:50:52 +0000
@@ -26,6 +26,7 @@
     'secondary_rack',
     'dhcp_on',
     'external_dhcp',
+    'relay_vlan',
 )
 
 
@@ -165,12 +166,18 @@
         :type vid: integer
         :param mtu: The MTU to use on the VLAN.
         :type mtu: integer
-        :Param dhcp_on: Whether or not DHCP should be managed on the VLAN.
+        :param dhcp_on: Whether or not DHCP should be managed on the VLAN.
         :type dhcp_on: boolean
         :param primary_rack: The primary rack controller managing the VLAN.
         :type primary_rack: system_id
         :param secondary_rack: The secondary rack controller manging the VLAN.
         :type secondary_rack: system_id
+        :param relay_vlan: Only set when this VLAN will be using a DHCP relay
+            to forward DHCP requests to another VLAN that MAAS is or will run
+            the DHCP server. MAAS will not run the DHCP relay itself, it must
+            be configured to proxy reqests to the primary and/or secondary
+            rack controller interfaces for the VLAN specified in this field.
+        :type relay_vlan: ID of VLAN
 
         Returns 404 if the fabric or VLAN is not found.
         """
 
=== modified file 'src/maasserver/bootresources.py'
--- src/maasserver/bootresources.py	2016-10-28 15:58:32 +0000
+++ src/maasserver/bootresources.py	2016-12-07 15:50:52 +0000
@@ -60,6 +60,7 @@
     BootResourceSet,
     BootSourceSelection,
     Config,
+    Event,
     LargeFile,
 )
 from maasserver.rpc import getAllClients
@@ -78,6 +79,7 @@
 from maasserver.utils.threads import deferToDatabase
 from maasserver.utils.version import get_maas_version_ui
 from provisioningserver.config import is_dev_environment
+from provisioningserver.events import EVENT_TYPES
 from provisioningserver.import_images.download_descriptions import (
     download_all_image_descriptions,
     image_passes_filter,
@@ -661,10 +663,13 @@
                 # not allowed.
                 prev_largefile = largefile
                 largefile = None
-                maaslog.warning(
+                msg = (
                     "Hash mismatch for prev_file=%s resourceset=%s "
-                    "resource=%s",
-                    prev_largefile, resource_set, resource)
+                    "resource=%s" % (prev_largefile, resource_set, resource)
+                )
+                Event.objects.create_region_event(
+                    EVENT_TYPES.REGION_IMPORT_WARNING, msg)
+                maaslog.warning(msg)
 
         if largefile is None:
             # The resource file current does not have a largefile linked. Lets
@@ -695,8 +700,10 @@
             is_resource_initially_complete and
             resource.get_latest_complete_set() is None)
         if is_resource_broken:
-            maaslog.error(
-                "Resource %s has no complete resource set!", resource)
+            msg = "Resource %s has no complete resource set!" % resource
+            Event.objects.create_region_event(
+                EVENT_TYPES.REGION_IMPORT_ERROR, msg)
+            maaslog.error(msg)
 
         if prev_largefile is not None:
             # If the previous largefile had a miss matching sha256 then it
@@ -773,11 +780,15 @@
             # Calculated sha256 hash from the data does not match, what
             # simplestreams is telling us it should be. This resource file
             # will be deleted since it is corrupt.
-            maaslog.error(
+            msg = (
                 "Failed to finalize boot image %s. Unexpected "
-                "checksum '%s' (found: %s expected: %s)",
-                ident, cksummer.algorithm,
-                cksummer.hexdigest(), cksummer.expected)
+                "checksum '%s' (found: %s expected: %s)" %
+                (
+                    ident, cksummer.algorithm, cksummer.hexdigest(),
+                    cksummer.expected))
+            Event.objects.create_region_event(
+                EVENT_TYPES.REGION_IMPORT_ERROR, msg)
+            maaslog.error(msg)
             transactional(rfile.delete)()
         else:
             maaslog.debug('Finalized boot image %s.', ident)
@@ -877,11 +888,15 @@
                             self.get_resource_identity(delete_resource))
                         delete_resource.delete()
                     else:
-                        maaslog.info(
+                        msg = (
                             "Boot image %s no longer exists in stream, but "
                             "remains in selections. To delete this image "
-                            "remove its selection.",
-                            self.get_resource_identity(delete_resource))
+                            "remove its selection." %
+                            self.get_resource_identity(delete_resource)
+                        )
+                        Event.objects.create_region_event(
+                            EVENT_TYPES.REGION_IMPORT_INFO, msg)
+                        maaslog.info(msg)
                 else:
                     # No resource set on the boot resource so it should be
                     # removed as it has not files.
@@ -960,6 +975,8 @@
                 "Finalization of imported images skipped, "
                 "or all %s synced images would be deleted." % (
                     self._resources_to_delete))
+            Event.objects.create_region_event(
+                EVENT_TYPES.REGION_IMPORT_ERROR, error_msg)
             maaslog.error(error_msg)
             if notify is not None:
                 failure = Failure(Exception(error_msg))
@@ -1192,7 +1209,10 @@
 
     # Download all of the metadata first.
     for source in sources:
-        maaslog.info("Importing images from source: %s", source['url'])
+        msg = "Importing images from source: %s" % source['url']
+        Event.objects.create_region_event(
+            EVENT_TYPES.REGION_IMPORT_INFO, msg)
+        maaslog.info(msg)
         download_boot_resources(
             source['url'], store, product_mapping,
             keyring_file=source.get('keyring'))
@@ -1318,15 +1338,21 @@
     with tempdir('keyrings') as keyrings_path:
         sources = get_boot_sources()
         sources = write_all_keyrings(keyrings_path, sources)
-        maaslog.info(
-            "Started importing of boot images from %d source(s).",
+        msg = (
+            "Started importing of boot images from %d source(s)." %
             len(sources))
+        Event.objects.create_region_event(EVENT_TYPES.REGION_IMPORT_INFO, msg)
+        maaslog.info(msg)
 
         image_descriptions = download_all_image_descriptions(sources)
         if image_descriptions.is_empty():
-            maaslog.warning(
+            msg = (
                 "Unable to import boot images, no image "
-                "descriptions avaliable.")
+                "descriptions avaliable."
+            )
+            Event.objects.create_region_event(
+                EVENT_TYPES.REGION_IMPORT_WARNING, msg)
+            maaslog.warning(msg)
             return
         product_mapping = map_products(image_descriptions)
 
 
=== modified file 'src/maasserver/clusterrpc/power_parameters.py'
--- src/maasserver/clusterrpc/power_parameters.py	2016-10-20 19:41:25 +0000
+++ src/maasserver/clusterrpc/power_parameters.py	2016-12-07 15:50:52 +0000
@@ -14,7 +14,7 @@
 power type with a set of power parameters.
 
 The power types are retrieved from the cluster controllers using the json
-schema provisioningserver.power_schema.JSON_POWER_TYPE_SCHEMA.  To add new
+schema provisioningserver.drivers.power.JSON_POWER_DRIVERS_SCHEMA.  To add new
 parameters requires changes to hardware drivers that run in the cluster
 controllers.
 """
@@ -33,10 +33,8 @@
 from maasserver.config_forms import DictCharField
 from maasserver.fields import MACAddressFormField
 from maasserver.utils.forms import compose_invalid_choice_text
-from provisioningserver.power.schema import (
-    JSON_POWER_TYPE_SCHEMA,
-    POWER_TYPE_PARAMETER_FIELD_SCHEMA,
-)
+from provisioningserver.drivers import SETTING_PARAMETER_FIELD_SCHEMA
+from provisioningserver.drivers.power import JSON_POWER_DRIVERS_SCHEMA
 from provisioningserver.rpc import cluster
 
 
@@ -93,10 +91,10 @@
     :type description: string
     :param fields: The fields that make up the parameters for the power
         type. Will be validated against
-        POWER_TYPE_PARAMETER_FIELD_SCHEMA.
+        SETTING_PARAMETER_FIELD_SCHEMA.
     :param missing_packages: System packages that must be installed on
         the cluster before the power type can be used.
-    :type fields: list of `make_json_field` results.
+    :type fields: list of `make_setting_field` results.
     :param parameters_set: An existing list of power type parameters to
         mutate.
     :type parameters_set: list
@@ -107,7 +105,7 @@
     field_set_schema = {
         'title': "Power type parameters field set schema",
         'type': 'array',
-        'items': POWER_TYPE_PARAMETER_FIELD_SCHEMA,
+        'items': SETTING_PARAMETER_FIELD_SCHEMA,
     }
     validate(fields, field_set_schema)
     parameters_set.append(
@@ -132,7 +130,7 @@
     :return: A dict of power parameters for all power types, indexed by
         power type name.
     """
-    validate(json_power_type_parameters, JSON_POWER_TYPE_SCHEMA)
+    validate(json_power_type_parameters, JSON_POWER_DRIVERS_SCHEMA)
     power_parameters = {
         # Empty type, for the case where nothing is entered in the form yet.
         '': DictCharField(
@@ -197,7 +195,7 @@
     """Query every cluster controller and obtain all known power types.
 
     :return: a list of power types matching the schema
-        provisioningserver.power_schema.JSON_POWER_TYPE_PARAMETERS_SCHEMA
+        provisioningserver.drivers.power.JSON_POWER_DRIVERS_SCHEMA
     """
     merged_types = []
     responses = call_clusters(
 
=== modified file 'src/maasserver/clusterrpc/testing/power_parameters.py'
--- src/maasserver/clusterrpc/testing/power_parameters.py	2016-06-22 17:03:02 +0000
+++ src/maasserver/clusterrpc/testing/power_parameters.py	2016-12-07 15:50:52 +0000
@@ -11,7 +11,7 @@
 
 from fixtures import Fixture
 from maasserver.clusterrpc import power_parameters
-from provisioningserver.power import schema
+from provisioningserver.drivers.power import PowerDriverRegistry
 from testtools import monkey
 
 
@@ -26,7 +26,9 @@
         super(StaticPowerTypesFixture, self).setUp()
         # This patch prevents communication with a non-existent cluster
         # controller when fetching power types.
+        power_types = PowerDriverRegistry.get_schema(
+            detect_missing_packages=False)
         restore = monkey.patch(
             power_parameters, 'get_all_power_types_from_clusters',
-            Mock(return_value=schema.JSON_POWER_TYPE_PARAMETERS))
+            Mock(return_value=power_types))
         self.addCleanup(restore)
 
=== modified file 'src/maasserver/clusterrpc/tests/test_power_parameters.py'
--- src/maasserver/clusterrpc/tests/test_power_parameters.py	2016-10-20 08:41:30 +0000
+++ src/maasserver/clusterrpc/tests/test_power_parameters.py	2016-12-07 15:50:52 +0000
@@ -14,9 +14,9 @@
     add_power_type_parameters,
     get_power_type_parameters_from_json,
     get_power_types,
-    JSON_POWER_TYPE_SCHEMA,
+    JSON_POWER_DRIVERS_SCHEMA,
     make_form_field,
-    POWER_TYPE_PARAMETER_FIELD_SCHEMA,
+    SETTING_PARAMETER_FIELD_SCHEMA,
 )
 from maasserver.config_forms import DictCharField
 from maasserver.fields import MACAddressFormField
@@ -25,7 +25,7 @@
 from maasserver.utils.forms import compose_invalid_choice_text
 from maastesting.matchers import MockCalledOnceWith
 from maastesting.testcase import MAASTestCase
-from provisioningserver.power.schema import make_json_field
+from provisioningserver.drivers import make_setting_field
 
 
 class TestGetPowerTypeParametersFromJSON(MAASServerTestCase):
@@ -186,15 +186,15 @@
         self.assertEquals(json_field['default'], django_field.initial)
 
 
-class TestMakeJSONField(MAASServerTestCase):
-    """Test that make_json_field() creates JSON-verifiable fields."""
+class TestMakeSettingField(MAASServerTestCase):
+    """Test that make_setting_field() creates JSON-verifiable fields."""
 
     def test__returns_json_verifiable_dict(self):
-        json_field = make_json_field('some_field', 'Some Label')
-        jsonschema.validate(json_field, POWER_TYPE_PARAMETER_FIELD_SCHEMA)
+        json_field = make_setting_field('some_field', 'Some Label')
+        jsonschema.validate(json_field, SETTING_PARAMETER_FIELD_SCHEMA)
 
     def test__provides_sane_default_values(self):
-        json_field = make_json_field('some_field', 'Some Label')
+        json_field = make_setting_field('some_field', 'Some Label')
         expected_field = {
             'name': 'some_field',
             'label': 'Some Label',
@@ -219,16 +219,16 @@
             'default': 'spam',
             'scope': 'bmc',
         }
-        json_field = make_json_field(**expected_field)
+        json_field = make_setting_field(**expected_field)
         self.assertEqual(expected_field, json_field)
 
     def test__validates_choices(self):
         self.assertRaises(
-            jsonschema.ValidationError, make_json_field,
+            jsonschema.ValidationError, make_setting_field,
             'some_field', 'Some Label', choices="Nonsense")
 
     def test__creates_password_fields(self):
-        json_field = make_json_field(
+        json_field = make_setting_field(
             'some_field', 'Some Label', field_type='password')
         expected_field = {
             'name': 'some_field',
@@ -245,7 +245,7 @@
 class TestAddPowerTypeParameters(MAASServerTestCase):
 
     def make_field(self):
-        return make_json_field(
+        return make_setting_field(
             self.getUniqueString(), self.getUniqueString())
 
     def test_adding_existing_types_is_a_no_op(self):
@@ -289,7 +289,7 @@
             missing_packages=[],
             parameters_set=parameters_set)
         jsonschema.validate(
-            parameters_set, JSON_POWER_TYPE_SCHEMA)
+            parameters_set, JSON_POWER_DRIVERS_SCHEMA)
 
 
 class TestPowerTypes(MAASTestCase):
 
=== modified file 'src/maasserver/dhcp.py'
--- src/maasserver/dhcp.py	2016-11-01 16:46:19 +0000
+++ src/maasserver/dhcp.py	2016-12-07 15:50:52 +0000
@@ -29,10 +29,7 @@
     IPRANGE_TYPE,
     SERVICE_STATUS,
 )
-from maasserver.exceptions import (
-    DHCPConfigurationError,
-    UnresolvableHost,
-)
+from maasserver.exceptions import UnresolvableHost
 from maasserver.models import (
     Config,
     DHCPSnippet,
@@ -40,6 +37,7 @@
     RackController,
     Service,
     StaticIPAddress,
+    Subnet,
 )
 from maasserver.rpc import (
     getAllClients,
@@ -88,14 +86,14 @@
     return key
 
 
-def split_ipv4_ipv6_subnets(subnets):
+def split_managed_ipv4_ipv6_subnets(subnets: Iterable[Subnet]):
     """Divide `subnets` into IPv4 ones and IPv6 ones.
 
     :param subnets: A sequence of subnets.
     :return: A tuple of two separate sequences: IPv4 subnets and IPv6 subnets.
     """
     split = defaultdict(list)
-    for subnet in subnets:
+    for subnet in (s for s in subnets if s.managed is True):
         split[subnet.get_ipnetwork().version].append(subnet)
     assert len(split) <= 2, (
         "Unexpected IP version(s): %s" % ', '.join(list(split.keys())))
@@ -193,18 +191,19 @@
         return []
 
 
-def get_managed_vlans_for(rack_controller):
-    """Return list of `VLAN` for the `rack_controller` when DHCP is enabled and
+def gen_managed_vlans_for(rack_controller):
+    """Yeilds each `VLAN` for the `rack_controller` when DHCP is enabled and
     `rack_controller` is either the `primary_rack` or the `secondary_rack`.
     """
     interfaces = rack_controller.interface_set.filter(
         Q(vlan__dhcp_on=True) & (
             Q(vlan__primary_rack=rack_controller) |
-            Q(vlan__secondary_rack=rack_controller))).select_related("vlan")
-    return {
-        interface.vlan
-        for interface in interfaces
-    }
+            Q(vlan__secondary_rack=rack_controller)))
+    interfaces = interfaces.prefetch_related("vlan__relay_vlans")
+    for interface in interfaces:
+        yield interface.vlan
+        for relayed_vlan in interface.vlan.relay_vlans.all():
+            yield relayed_vlan
 
 
 def ip_is_on_vlan(ip_address, vlan):
@@ -459,12 +458,6 @@
     interfaces = get_interfaces_with_ip_on_vlan(
         rack_controller, vlan, ip_version)
     interface = get_best_interface(interfaces)
-    if interface is None:
-        raise DHCPConfigurationError(
-            "No IPv%d interface on rack controller '%s' has an IP address on "
-            "any subnet on VLAN '%s.%d'." % (
-                ip_version, rack_controller.hostname, vlan.fabric.name,
-                vlan.vid))
 
     # Generate the failover peer for this VLAN.
     if vlan.secondary_rack_id is not None:
@@ -496,7 +489,7 @@
     hosts = make_hosts_for_subnets(subnets, nodes_dhcp_snippets)
     return (
         peer_config, sorted(subnet_configs, key=itemgetter("subnet")),
-        hosts, interface.name)
+        hosts, None if interface is None else interface.name)
 
 
 @synchronous
@@ -505,11 +498,11 @@
     """Return tuple with IPv4 and IPv6 configurations for the
     rack controller."""
     # Get list of all vlans that are being managed by the rack controller.
-    vlans = get_managed_vlans_for(rack_controller)
+    vlans = gen_managed_vlans_for(rack_controller)
 
     # Group the subnets on each VLAN into IPv4 and IPv6 subnets.
     vlan_subnets = {
-        vlan: split_ipv4_ipv6_subnets(vlan.subnet_set.all())
+        vlan: split_managed_ipv4_ipv6_subnets(vlan.subnet_set.all())
         for vlan in vlans
     }
 
@@ -561,52 +554,40 @@
     for vlan, (subnets_v4, subnets_v6) in vlan_subnets.items():
         # IPv4
         if len(subnets_v4) > 0:
-            try:
-                config = get_dhcp_configure_for(
-                    4, rack_controller, vlan, subnets_v4, ntp_servers,
-                    default_domain, dhcp_snippets)
-            except DHCPConfigurationError:
-                # XXX bug #1602412: this silently breaks DHCPv4, but we cannot
-                # allow it to crash here since DHCPv6 might be able to run.
-                # This error may be irrelevant if there is an IPv4 network in
-                # the MAAS model which is not configured on the rack, and the
-                # user only wants to serve DHCPv6. But it is still something
-                # worth noting, so log it and continue.
-                log.err(None, "Failure configuring DHCPv4.")
-            else:
-                failover_peer, subnets, hosts, interface = config
-                if failover_peer is not None:
-                    failover_peers_v4.append(failover_peer)
-                shared_networks_v4.append({
-                    "name": "vlan-%d" % vlan.id,
-                    "subnets": subnets,
-                })
-                hosts_v4.extend(hosts)
+            config = get_dhcp_configure_for(
+                4, rack_controller, vlan, subnets_v4, ntp_servers,
+                default_domain, dhcp_snippets)
+            failover_peer, subnets, hosts, interface = config
+            if failover_peer is not None:
+                failover_peers_v4.append(failover_peer)
+            shared_networks_v4.append({
+                "name": "vlan-%d" % vlan.id,
+                "subnets": subnets,
+            })
+            hosts_v4.extend(hosts)
+            if interface is not None:
                 interfaces_v4.add(interface)
         # IPv6
         if len(subnets_v6) > 0:
-            try:
-                config = get_dhcp_configure_for(
-                    6, rack_controller, vlan, subnets_v6,
-                    ntp_servers, default_domain, dhcp_snippets)
-            except DHCPConfigurationError:
-                # XXX bug #1602412: this silently breaks DHCPv6, but we cannot
-                # allow it to crash here since DHCPv4 might be able to run.
-                # This error may be irrelevant if there is an IPv6 network in
-                # the MAAS model which is not configured on the rack, and the
-                # user only wants to serve DHCPv4. But it is still something
-                # worth noting, so log it and continue.
-                log.err(None, "Failure configuring DHCPv6.")
-            else:
-                failover_peer, subnets, hosts, interface = config
-                if failover_peer is not None:
-                    failover_peers_v6.append(failover_peer)
-                shared_networks_v6.append({
-                    "name": "vlan-%d" % vlan.id,
-                    "subnets": subnets,
-                })
-                hosts_v6.extend(hosts)
+            config = get_dhcp_configure_for(
+                6, rack_controller, vlan, subnets_v6,
+                ntp_servers, default_domain, dhcp_snippets)
+            failover_peer, subnets, hosts, interface = config
+            if failover_peer is not None:
+                failover_peers_v6.append(failover_peer)
+            shared_networks_v6.append({
+                "name": "vlan-%d" % vlan.id,
+                "subnets": subnets,
+            })
+            hosts_v6.extend(hosts)
+            if interface is not None:
                 interfaces_v6.add(interface)
+    # When no interfaces exist for each IP version clear the shared networks
+    # as DHCP server cannot be started and needs to be stopped.
+    if len(interfaces_v4) == 0:
+        shared_networks_v4 = {}
+    if len(interfaces_v6) == 0:
+        shared_networks_v6 = {}
     return DHCPConfigurationForRack(
         failover_peers_v4, shared_networks_v4, hosts_v4, interfaces_v4,
         failover_peers_v6, shared_networks_v6, hosts_v6, interfaces_v6,
 
=== renamed directory 'src/maas' => 'src/maasserver/djangosettings'
=== modified file 'src/maasserver/djangosettings/demo.py'
--- src/maas/demo.py	2016-06-07 19:59:49 +0000
+++ src/maasserver/djangosettings/demo.py	2016-12-07 15:50:52 +0000
@@ -5,7 +5,7 @@
 
 from os.path import abspath
 
-from maas import (
+from maasserver.djangosettings import (
     development,
     import_settings,
     settings,
 
=== modified file 'src/maasserver/djangosettings/development.py'
--- src/maas/development.py	2016-10-18 11:21:26 +0000
+++ src/maasserver/djangosettings/development.py	2016-12-07 15:50:52 +0000
@@ -7,7 +7,7 @@
 from os.path import abspath
 
 from formencode.validators import StringBool
-from maas import (
+from maasserver.djangosettings import (
     fix_up_databases,
     import_settings,
     settings,
 
=== modified file 'src/maasserver/djangosettings/settings.py'
--- src/maas/settings.py	2016-11-22 00:53:43 +0000
+++ src/maasserver/djangosettings/settings.py	2016-12-07 15:50:52 +0000
@@ -6,9 +6,9 @@
 import os
 
 import django.template.base
-from maas import fix_up_databases
-from maas.monkey import patch_get_script_prefix
 from maasserver.config import RegionConfiguration
+from maasserver.djangosettings import fix_up_databases
+from maasserver.djangosettings.monkey import patch_get_script_prefix
 
 
 def _read_timezone(tzfilename='/etc/timezone'):
@@ -265,7 +265,7 @@
 
 )
 
-ROOT_URLCONF = 'maas.urls'
+ROOT_URLCONF = 'maasserver.djangosettings.urls'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates"
 
=== renamed file 'src/maas/tests/test_maas.py' => 'src/maasserver/djangosettings/tests/test_settings.py'
--- src/maas/tests/test_maas.py	2016-06-21 10:29:11 +0000
+++ src/maasserver/djangosettings/tests/test_settings.py	2016-12-07 15:50:52 +0000
@@ -10,11 +10,11 @@
 
 from django.conf import settings
 from django.db import connections
-from maas import (
+from maasserver.djangosettings import (
     find_settings,
     import_settings,
 )
-from maas.settings import (
+from maasserver.djangosettings.settings import (
     _get_local_timezone,
     _read_timezone,
 )
 
=== modified file 'src/maasserver/enum.py'
--- src/maasserver/enum.py	2016-09-08 17:26:54 +0000
+++ src/maasserver/enum.py	2016-12-07 15:50:52 +0000
@@ -154,6 +154,8 @@
     RACK_CONTROLLER = 2
     REGION_CONTROLLER = 3
     REGION_AND_RACK_CONTROLLER = 4
+    CHASSIS = 5
+    STORAGE = 6
 
 
 # This is copied in static/js/angular/controllers/subnet_details.js. If you
@@ -164,6 +166,8 @@
     (NODE_TYPE.RACK_CONTROLLER, "Rack controller"),
     (NODE_TYPE.REGION_CONTROLLER, "Region controller"),
     (NODE_TYPE.REGION_AND_RACK_CONTROLLER, "Region and rack controller"),
+    (NODE_TYPE.CHASSIS, "Chassis"),
+    (NODE_TYPE.STORAGE, "Storage"),
 )
 
 
 
=== modified file 'src/maasserver/exceptions.py'
--- src/maasserver/exceptions.py	2016-03-28 13:54:47 +0000
+++ src/maasserver/exceptions.py	2016-12-07 15:50:52 +0000
@@ -199,7 +199,3 @@
     information.
     """
     api_error = int(http.client.SERVICE_UNAVAILABLE)
-
-
-class DHCPConfigurationError(MAASException):
-    """Raised when the configuration of DHCP hits a problem."""
 
=== modified file 'src/maasserver/forms_commission.py'
--- src/maasserver/forms_commission.py	2015-12-01 18:12:59 +0000
+++ src/maasserver/forms_commission.py	2016-12-07 15:50:52 +0000
@@ -9,7 +9,6 @@
 
 from django import forms
 from django.core.exceptions import ValidationError
-from maasserver.enum import POWER_STATE
 from maasserver.node_action import compile_node_actions
 
 
@@ -36,10 +35,6 @@
             raise ValidationError(
                 "Commission is not available because of the current state "
                 "of the node.")
-        if self.instance.power_state == POWER_STATE.ON:
-            raise ValidationError(
-                "Commission is not available because of the node is currently "
-                "powered on.")
         return cleaned_data
 
     def save(self):
 
=== modified file 'src/maasserver/forms_subnet.py'
--- src/maasserver/forms_subnet.py	2016-09-23 01:32:02 +0000
+++ src/maasserver/forms_subnet.py	2016-12-07 15:50:52 +0000
@@ -43,6 +43,9 @@
     allow_proxy = forms.BooleanField(
         required=False)
 
+    managed = forms.BooleanField(
+        required=False)
+
     class Meta:
         model = Subnet
         fields = (
@@ -56,6 +59,7 @@
             'rdns_mode',
             'active_discovery',
             'allow_proxy',
+            'managed',
             )
 
     def __init__(self, *args, **kwargs):
@@ -64,9 +68,12 @@
 
     def clean(self):
         cleaned_data = super(SubnetForm, self).clean()
-        # The default value for allow_proxy is True.
+        # The default value for 'allow_proxy' is True.
         if 'allow_proxy' not in self.data:
             cleaned_data['allow_proxy'] = True
+        # The default value for 'managed' is True.
+        if 'managed' not in self.data:
+            cleaned_data['managed'] = True
         # The ArrayField form has a bug which leaves out the first entry.
         if 'dns_servers' in self.data and self.data['dns_servers'] != '':
             cleaned_data['dns_servers'] = self.data.getlist('dns_servers')
 
=== modified file 'src/maasserver/forms_vlan.py'
--- src/maasserver/forms_vlan.py	2016-04-27 20:38:06 +0000
+++ src/maasserver/forms_vlan.py	2016-12-07 15:50:52 +0000
@@ -31,6 +31,7 @@
             'dhcp_on',
             'primary_rack',
             'secondary_rack',
+            'relay_vlan',
             )
 
     def __init__(self, *args, **kwargs):
@@ -40,6 +41,7 @@
         if instance is None and self.fabric is None:
             raise ValueError("Form requires either a instance or a fabric.")
         self._set_up_rack_fields()
+        self._set_up_relay_vlan()
 
     def _set_up_rack_fields(self):
         qs = RackController.objects.filter_by_vids([self.instance.vid])
@@ -61,6 +63,22 @@
             secondary_rack = RackController.objects.get(id=secondary_rack_id)
             self.initial['secondary_rack'] = secondary_rack.system_id
 
+    def _set_up_relay_vlan(self):
+        # Configure the relay_vlan fields to include only VLAN's that are
+        # not already on a relay_vlan. If this is an update then it cannot
+        # be itself or never set when dhcp_on is True.
+        possible_relay_vlans = VLAN.objects.filter(relay_vlan__isnull=True)
+        if self.instance is not None:
+            possible_relay_vlans = possible_relay_vlans.exclude(
+                id=self.instance.id)
+            if self.instance.dhcp_on:
+                possible_relay_vlans = VLAN.objects.none()
+                if self.instance.relay_vlan is not None:
+                    possible_relay_vlans = VLAN.objects.filter(
+                        id=self.instance.relay_vlan.id)
+        self.fields['relay_vlan'] = forms.ModelChoiceField(
+            queryset=possible_relay_vlans, required=False)
+
     def clean(self):
         cleaned_data = super(VLANForm, self).clean()
         # Automatically promote the secondary rack controller to the primary
@@ -120,5 +138,12 @@
         interface = super(VLANForm, self).save(commit=False)
         if self.fabric is not None:
             interface.fabric = self.fabric
+        if ('relay_vlan' in self.data and
+                not self.cleaned_data.get('relay_vlan')):
+            # relay_vlan is being cleared.
+            interface.relay_vlan = None
+        if interface.dhcp_on:
+            # relay_vlan cannot be set when dhcp is on.
+            interface.relay_vlan = None
         interface.save()
         return interface
 
=== modified file 'src/maasserver/locks.py'
--- src/maasserver/locks.py	2016-09-28 14:12:23 +0000
+++ src/maasserver/locks.py	2016-12-07 15:50:52 +0000
@@ -4,6 +4,7 @@
 """Region-wide locks."""
 
 __all__ = [
+    "address_allocation",
     "dns",
     "eventloop",
     "import_images",
@@ -11,7 +12,6 @@
     "rack_registration",
     "security",
     "startup",
-    "staticip_acquire",
 ]
 
 from maasserver.utils.dblocks import (
@@ -38,8 +38,8 @@
 # Lock to prevent concurrent acquisition of nodes.
 node_acquire = DatabaseXactLock(7)
 
-# Lock to prevent concurrent allocation of StaticIPAddress
-staticip_acquire = DatabaseXactLock(8)
+# Lock to help with concurrent allocation of IP addresses.
+address_allocation = DatabaseLock(8)
 
 # Lock to prevent concurrent registration of rack controllers. This can be a
 # problem because registration involves populating fabrics, VLANs, and other
 
=== modified file 'src/maasserver/management/commands/dbupgrade.py'
--- src/maasserver/management/commands/dbupgrade.py	2016-09-04 19:57:50 +0000
+++ src/maasserver/management/commands/dbupgrade.py	2016-12-07 15:50:52 +0000
@@ -9,6 +9,7 @@
 __all__ = []
 
 from importlib import import_module
+import json
 import optparse
 import os
 import shutil
@@ -34,7 +35,7 @@
 # Script that performs the south migrations for MAAS under django 1.6 and
 # python2.7.
 MAAS_UPGRADE_SCRIPT = """\
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 from __future__ import (
@@ -46,12 +47,49 @@
 str = None
 
 __metaclass__ = type
-__all__ = [
-    ]
+__all__ = []
 
 import os
 import sys
 
+import django.conf
+
+
+class LazySettings(django.conf.LazySettings):
+    '''Prevent Django from mangling warnings settings.
+
+    At present, Django adds a single filter that surfaces all deprecation
+    warnings, but MAAS handles them differently. Django doesn't appear to give
+    a way to prevent it from doing its thing, so we must undo its changes.
+
+    Deprecation warnings in production environments are not desirable as they
+    are a developer tool, and not something an end user can reasonably do
+    something about. This brings control of warnings back into MAAS's control.
+    '''
+
+    def _configure_logging(self):
+        # This is a copy of *half* of Django's `_configure_logging`, omitting
+        # the problematic bits.
+        if self.LOGGING_CONFIG:
+            from django.utils.log import DEFAULT_LOGGING
+            from django.utils.module_loading import import_by_path
+            # First find the logging configuration function ...
+            logging_config_func = import_by_path(self.LOGGING_CONFIG)
+            logging_config_func(DEFAULT_LOGGING)
+            # ... then invoke it with the logging settings
+            if self.LOGGING:
+                logging_config_func(self.LOGGING)
+
+
+# Install our `LazySettings` as the Django-global settings class. First,
+# ensure that Django hasn't yet loaded its settings.
+assert not django.conf.settings.configured
+# This is needed because Django's `LazySettings` overrides `__setattr__`.
+object.__setattr__(django.conf.settings, "__class__", LazySettings)
+
+# Force Django configuration.
+os.environ["DJANGO_SETTINGS_MODULE"] = "maas19settings"
+
 # Inject the sys.path from the parent process so that the python path is
 # is similar, except that the directory that this script is running from is
 # already the first path in sys.path.
@@ -132,6 +170,11 @@
         tempdir = tempfile.mkdtemp(prefix='maas-upgrade-')
         subprocess.check_call([
             "tar", "zxf", path_to_tarball, "-C", tempdir])
+
+        settings_json = os.path.join(tempdir, "maas19settings.json")
+        with open(settings_json, "w", encoding="utf-8") as fd:
+            fd.write(json.dumps({"DATABASES": settings.DATABASES}))
+
         script_path = os.path.join(tempdir, "migrate.py")
         with open(script_path, "wb") as fp:
             fp.write(MAAS_UPGRADE_SCRIPT.encode("utf-8"))
 
=== modified file 'src/maasserver/management/commands/tests/test_dbupgrade.py'
--- src/maasserver/management/commands/tests/test_dbupgrade.py	2016-03-28 13:54:47 +0000
+++ src/maasserver/management/commands/tests/test_dbupgrade.py	2016-12-07 15:50:52 +0000
@@ -64,7 +64,10 @@
         env = os.environ.copy()
         env["MAAS_PREVENT_MIGRATIONS"] = "0"
         mra = os.path.join(root, "bin", "maas-region")
-        cmd = [mra, "dbupgrade", "--settings", "maas.settings"]
+        cmd = [
+            mra, "dbupgrade", "--settings",
+            "maasserver.djangosettings.settings",
+        ]
         if always_south:
             cmd.append("--always-south")
         self.execute(cmd, env=env)
 
=== modified file 'src/maasserver/migrations/builtin/maasserver/0016_migrate_power_data_node_to_bmc.py'
--- src/maasserver/migrations/builtin/maasserver/0016_migrate_power_data_node_to_bmc.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/migrations/builtin/maasserver/0016_migrate_power_data_node_to_bmc.py	2016-12-07 15:50:52 +0000
@@ -2,10 +2,8 @@
 
 from django.db import migrations
 from maasserver.models import timestampedmodel
-from provisioningserver.power.schema import (
-    POWER_FIELDS_BY_TYPE,
-    POWER_PARAMETER_SCOPE,
-)
+from provisioningserver.drivers import SETTING_SCOPE
+from provisioningserver.drivers.power import PowerDriverRegistry
 
 # Copied from BMC model.
 def scope_power_parameters(power_type, power_params):
@@ -14,16 +12,20 @@
     if not power_type:
         # If there is no power type, treat all params as node params.
         return ({}, power_params)
-    power_fields = POWER_FIELDS_BY_TYPE.get(power_type)
+    power_driver = PowerDriverRegistry.get_item(power_type)
+    if power_driver is None:
+        # If there is no power driver, treat all params as node params.
+        return ({}, power_params)
+    power_fields = power_driver.settings
     if not power_fields:
         # If there is no parameter info, treat all params as node params.
         return ({}, power_params)
     bmc_params = {}
     node_params = {}
     for param_name in power_params:
-        power_field = power_fields.get(param_name)
+        power_field = power_driver.get_setting(param_name)
         if power_field and power_field.get(
-                'scope') == POWER_PARAMETER_SCOPE.BMC:
+                'scope') == SETTING_SCOPE.BMC:
             bmc_params[param_name] = power_params[param_name]
         else:
             node_params[param_name] = power_params[param_name]
 
=== modified file 'src/maasserver/migrations/builtin/maasserver/0022_extract_ip_for_bmcs.py'
--- src/maasserver/migrations/builtin/maasserver/0022_extract_ip_for_bmcs.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/migrations/builtin/maasserver/0022_extract_ip_for_bmcs.py	2016-12-07 15:50:52 +0000
@@ -8,7 +8,7 @@
 )
 from maasserver.enum import IPADDRESS_TYPE
 from maasserver.models import timestampedmodel
-from provisioningserver.power.schema import POWER_TYPE_PARAMETERS_BY_NAME
+from provisioningserver.drivers.power import PowerDriverRegistry
 
 # Derived from Subnet model.
 def raw_subnet_id_containing_ip(ip):
@@ -38,10 +38,13 @@
     # power_address field, returns None.
     if not power_type or not power_parameters:
         return None
-    power_type_parameters = POWER_TYPE_PARAMETERS_BY_NAME.get(power_type)
+    power_driver = PowerDriverRegistry.get_item(power_type)
+    if power_driver is None:
+        return None
+    power_type_parameters = power_driver.settings
     if not power_type_parameters:
         return None
-    ip_extractor = power_type_parameters.get('ip_extractor')
+    ip_extractor = power_driver.ip_extractor
     if not ip_extractor:
         return None
     field_value = power_parameters.get(ip_extractor.get('field_name'))
 
=== modified file 'src/maasserver/migrations/builtin/maasserver/0027_replace_static_range_with_admin_reserved_ranges.py'
--- src/maasserver/migrations/builtin/maasserver/0027_replace_static_range_with_admin_reserved_ranges.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/migrations/builtin/maasserver/0027_replace_static_range_with_admin_reserved_ranges.py	2016-12-07 15:50:52 +0000
@@ -37,7 +37,7 @@
         IPRange, subnet, ranges, created_time, range_description):
     unreserved_range_set = MAASIPSet(ranges)
     unreserved_ranges = unreserved_range_set.get_unused_ranges(
-        subnet.cidr, comment="reserved")
+        subnet.cidr, purpose="reserved")
     for iprange in unreserved_ranges:
         start_ip = str(IPAddress(iprange.first))
         end_ip = str(IPAddress(iprange.last))
 
=== modified file 'src/maasserver/migrations/builtin/maasserver/0056_add_description_to_fabric_and_space.py'
--- src/maasserver/migrations/builtin/maasserver/0056_add_description_to_fabric_and_space.py	2016-07-30 01:17:54 +0000
+++ src/maasserver/migrations/builtin/maasserver/0056_add_description_to_fabric_and_space.py	2016-12-07 15:50:52 +0000
@@ -44,6 +44,6 @@
         migrations.AlterField(
             model_name='subnet',
             name='vlan',
-            field=models.ForeignKey(to='maasserver.VLAN', default=maasserver.models.subnet.get_default_vlan, on_delete=django.db.models.deletion.PROTECT),
+            field=models.ForeignKey(to='maasserver.VLAN', default=None, on_delete=django.db.models.deletion.PROTECT),
         ),
     ]
 
=== added file 'src/maasserver/migrations/builtin/maasserver/0094_add_unmanaged_subnets.py'
--- src/maasserver/migrations/builtin/maasserver/0094_add_unmanaged_subnets.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0094_add_unmanaged_subnets.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0093_add_rdns_model'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='subnet',
+            name='managed',
+            field=models.BooleanField(default=True),
+        ),
+    ]
 
=== added file 'src/maasserver/migrations/builtin/maasserver/0095_vlan_relay_vlan.py'
--- src/maasserver/migrations/builtin/maasserver/0095_vlan_relay_vlan.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0095_vlan_relay_vlan.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0094_add_unmanaged_subnets'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='vlan',
+            name='relay_vlan',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.SET_NULL, null=True, blank=True, related_name='relay_vlans', to='maasserver.VLAN'),
+        ),
+    ]
 
=== added file 'src/maasserver/migrations/builtin/maasserver/0096_set_default_vlan_field.py'
--- src/maasserver/migrations/builtin/maasserver/0096_set_default_vlan_field.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0096_set_default_vlan_field.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+import django.db.models.deletion
+import maasserver.models.subnet
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0095_vlan_relay_vlan'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='subnet',
+            name='vlan',
+            field=models.ForeignKey(to='maasserver.VLAN', default=maasserver.models.subnet.get_default_vlan, on_delete=django.db.models.deletion.PROTECT),
+        ),
+    ]
 
=== added file 'src/maasserver/migrations/builtin/maasserver/0097_node_chassis_storage_hints.py'
--- src/maasserver/migrations/builtin/maasserver/0097_node_chassis_storage_hints.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0097_node_chassis_storage_hints.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+import django.db.models.deletion
+import maasserver.models.cleansave
+import maasserver.models.node
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0096_set_default_vlan_field'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ChassisHints',
+            fields=[
+                ('id', models.AutoField(primary_key=True, serialize=False, auto_created=True, verbose_name='ID')),
+                ('cores', models.IntegerField(default=0)),
+                ('memory', models.IntegerField(default=0)),
+                ('local_storage', models.IntegerField(default=0)),
+            ],
+            bases=(maasserver.models.cleansave.CleanSave, models.Model),
+        ),
+        migrations.CreateModel(
+            name='Chassis',
+            fields=[
+            ],
+            options={
+                'proxy': True,
+            },
+            bases=('maasserver.node',),
+        ),
+        migrations.CreateModel(
+            name='Storage',
+            fields=[
+            ],
+            options={
+                'proxy': True,
+            },
+            bases=('maasserver.node',),
+        ),
+        migrations.AddField(
+            model_name='node',
+            name='cpu_speed',
+            field=models.IntegerField(default=0),
+        ),
+        migrations.AddField(
+            model_name='node',
+            name='dynamic',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AlterField(
+            model_name='node',
+            name='domain',
+            field=models.ForeignKey(to='maasserver.Domain', null=True, default=maasserver.models.node.get_default_domain, blank=True, on_delete=django.db.models.deletion.PROTECT),
+        ),
+        migrations.AlterField(
+            model_name='node',
+            name='node_type',
+            field=models.IntegerField(choices=[(0, 'Machine'), (1, 'Device'), (2, 'Rack controller'), (3, 'Region controller'), (4, 'Region and rack controller'), (5, 'Chassis'), (6, 'Storage')], default=0, editable=False),
+        ),
+        migrations.AddField(
+            model_name='chassishints',
+            name='chassis',
+            field=models.OneToOneField(to='maasserver.Node', related_name='chassis_hints'),
+        ),
+    ]
 
=== renamed file 'src/maasserver/migrations/south/django16_south_maas19.tar.gz' => 'src/maasserver/migrations/south/django16_south_maas19.tar.gz.OTHER'
 Binary files src/maasserver/migrations/south/django16_south_maas19.tar.gz	2016-11-22 00:53:43 +0000 and src/maasserver/migrations/south/django16_south_maas19.tar.gz.OTHER	2016-12-07 15:50:52 +0000 differ
=== modified file 'src/maasserver/models/__init__.py'
--- src/maasserver/models/__init__.py	2016-10-18 22:22:23 +0000
+++ src/maasserver/models/__init__.py	2016-12-07 15:50:52 +0000
@@ -16,6 +16,8 @@
     'BootSourceSelection',
     'BridgeInterface',
     'CacheSet',
+    'Chassis',
+    'ChassisHints',
     'ComponentError',
     'Config',
     'Controller',
@@ -59,6 +61,7 @@
     'RegionRackRPCConnection',
     'Service',
     'Space',
+    'Storage',
     'SSHKey',
     'SSLKey',
     'StaticIPAddress',
@@ -98,6 +101,7 @@
 from maasserver.models.bootsourcecache import BootSourceCache
 from maasserver.models.bootsourceselection import BootSourceSelection
 from maasserver.models.cacheset import CacheSet
+from maasserver.models.chassishints import ChassisHints
 from maasserver.models.component_error import ComponentError
 from maasserver.models.config import Config
 from maasserver.models.dhcpsnippet import DHCPSnippet
@@ -133,6 +137,7 @@
 from maasserver.models.mdns import MDNS
 from maasserver.models.neighbour import Neighbour
 from maasserver.models.node import (
+    Chassis,
     Controller,
     Device,
     Machine,
@@ -140,6 +145,7 @@
     NodeGroupToRackController,
     RackController,
     RegionController,
+    Storage,
 )
 from maasserver.models.ownerdata import OwnerData
 from maasserver.models.packagerepository import PackageRepository
 
=== modified file 'src/maasserver/models/bmc.py'
--- src/maasserver/models/bmc.py	2016-06-04 00:21:58 +0000
+++ src/maasserver/models/bmc.py	2016-12-07 15:50:52 +0000
@@ -25,12 +25,9 @@
 from maasserver.models.subnet import Subnet
 from maasserver.models.timestampedmodel import TimestampedModel
 from maasserver.rpc import getAllClients
+from provisioningserver.drivers import SETTING_SCOPE
+from provisioningserver.drivers.power import PowerDriverRegistry
 from provisioningserver.logger import get_maas_logger
-from provisioningserver.power.schema import (
-    POWER_FIELDS_BY_TYPE,
-    POWER_PARAMETER_SCOPE,
-    POWER_TYPE_PARAMETERS_BY_NAME,
-)
 
 
 maaslog = get_maas_logger("node")
@@ -125,16 +122,20 @@
         if not power_type:
             # If there is no power type, treat all params as node params.
             return ({}, power_params)
-        power_fields = POWER_FIELDS_BY_TYPE.get(power_type)
+        power_driver = PowerDriverRegistry.get_item(power_type)
+        if power_driver is None:
+            # If there is no power driver, treat all params as node params.
+            return ({}, power_params)
+        power_fields = power_driver.settings
         if not power_fields:
             # If there is no parameter info, treat all params as node params.
             return ({}, power_params)
         bmc_params = {}
         node_params = {}
         for param_name in power_params:
-            power_field = power_fields.get(param_name)
+            power_field = power_driver.get_setting(param_name)
             if (power_field and
-                    power_field.get('scope') == POWER_PARAMETER_SCOPE.BMC):
+                    power_field.get('scope') == SETTING_SCOPE.BMC):
                 bmc_params[param_name] = power_params[param_name]
             else:
                 node_params[param_name] = power_params[param_name]
@@ -148,12 +149,17 @@
         if not power_type or not power_parameters:
             # Nothing to extract.
             return None
-        power_type_parameters = POWER_TYPE_PARAMETERS_BY_NAME.get(power_type)
+        power_driver = PowerDriverRegistry.get_item(power_type)
+        if power_driver is None:
+            maaslog.warning(
+                "No power driver for power type %s" % power_type)
+            return None
+        power_type_parameters = power_driver.settings
         if not power_type_parameters:
             maaslog.warning(
-                "No POWER_TYPE_PARAMETERS for power type %s" % power_type)
+                "No power driver settings for power type %s" % power_type)
             return None
-        ip_extractor = power_type_parameters.get('ip_extractor')
+        ip_extractor = power_driver.ip_extractor
         if not ip_extractor:
             maaslog.info(
                 "No IP extractor configured for power type %s. "
 
=== added file 'src/maasserver/models/chassishints.py'
--- src/maasserver/models/chassishints.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/models/chassishints.py	2016-12-07 15:50:52 +0000
@@ -0,0 +1,33 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Model that holds hint information for a Chassis."""
+
+__all__ = [
+    'ChassisHints',
+    ]
+
+
+from django.db.models import (
+    IntegerField,
+    Model,
+    OneToOneField,
+)
+from maasserver import DefaultMeta
+from maasserver.models.cleansave import CleanSave
+from maasserver.models.node import Node
+
+
+class ChassisHints(CleanSave, Model):
+    """Hint information for a chassis."""
+
+    class Meta(DefaultMeta):
+        """Needed for South to recognize this model."""
+
+    chassis = OneToOneField(Node, related_name="chassis_hints")
+
+    cores = IntegerField(default=0)
+
+    memory = IntegerField(default=0)
+
+    local_storage = IntegerField(default=0)
 
=== modified file 'src/maasserver/models/event.py'
--- src/maasserver/models/event.py	2016-10-25 13:57:02 +0000
+++ src/maasserver/models/event.py	2016-12-07 15:50:52 +0000
@@ -1,4 +1,4 @@
-# Copyright 2014-2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2014-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """:class:`Event` and friends."""
@@ -21,6 +21,7 @@
 from maasserver.models.timestampedmodel import TimestampedModel
 from provisioningserver.events import EVENT_DETAILS
 from provisioningserver.logger import get_maas_logger
+from provisioningserver.utils.env import get_maas_id
 
 
 maaslog = get_maas_logger('models.event')
@@ -56,6 +57,12 @@
             event_action=event_action,
             event_description=event_description)
 
+    def create_region_event(self, event_type, event_description=''):
+        """Helper to register event and event type for the running region."""
+        self.create_node_event(
+            system_id=get_maas_id(), event_type=event_type,
+            event_description=event_description)
+
 
 class Event(CleanSave, TimestampedModel):
     """An `Event` represents a MAAS event.
 
=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2016-12-07 11:26:49 +0000
+++ src/maasserver/models/node.py	2016-12-07 15:50:52 +0000
@@ -158,12 +158,12 @@
 )
 import petname
 from piston3.models import Token
+from provisioningserver.drivers.power import PowerDriverRegistry
 from provisioningserver.events import (
     EVENT_DETAILS,
     EVENT_TYPES,
 )
 from provisioningserver.logger import get_maas_logger
-from provisioningserver.power import QUERY_POWER_TYPES
 from provisioningserver.refresh import (
     get_sys_info,
     refresh,
@@ -265,32 +265,6 @@
             "we could find no unused node identifiers." % attempt)
 
 
-def typecast_node(node, model):
-    """Typecast a node object into a node type object."""
-    assert(isinstance(node, Node))
-    assert(issubclass(model, Node))
-    node.__class__ = model
-    return node
-
-
-def typecast_to_node_type(node):
-    """Typecast a node object to what the node_type is set to."""
-    if node.node_type == NODE_TYPE.MACHINE:
-        return typecast_node(node, Machine)
-    elif node.node_type in (
-            NODE_TYPE.RACK_CONTROLLER,
-            NODE_TYPE.REGION_AND_RACK_CONTROLLER):
-        # XXX ltrager 18-02-2016 - Currently only rack controllers have
-        # unique functionality so when combined return a rack controller
-        return typecast_node(node, RackController)
-    elif node.node_type == NODE_TYPE.REGION_CONTROLLER:
-        return typecast_node(node, RegionController)
-    elif node.node_type == NODE_TYPE.DEVICE:
-        return typecast_node(node, Device)
-    else:
-        raise NotImplementedError("Unknown node type %d" % node.node_type)
-
-
 class NodeQueriesMixin(MAASQueriesMixin):
 
     def filter_by_spaces(self, spaces):
@@ -520,7 +494,7 @@
         node = get_object_or_404(
             self.model, system_id=system_id, **kwargs)
         if user.has_perm(perm, node):
-            return typecast_to_node_type(node)
+            return node.as_self()
         else:
             raise PermissionDenied()
 
@@ -573,6 +547,19 @@
     extra_filters = {'node_type': NODE_TYPE.DEVICE}
 
 
+class ChassisManager(BaseNodeManager):
+    """Chassis are nodes that contain or can compose more machines or
+    storage."""
+
+    extra_filters = {'node_type': NODE_TYPE.CHASSIS}
+
+
+class StorageManager(BaseNodeManager):
+    """Storage are nodes that provide storage to other machines."""
+
+    extra_filters = {'node_type': NODE_TYPE.STORAGE}
+
+
 class ControllerManager(BaseNodeManager):
     """All controllers `RackController`, `RegionController`, and
     `RegionRackController`."""
@@ -746,7 +733,8 @@
             update_fields.append("owner")
         if len(update_fields) > 0:
             node.save(update_fields=update_fields)
-        return typecast_node(node, self.model)
+        # Always cast to a region controller.
+        return node.as_region_controller()
 
     def _create_running_controller(self):
         """Create a region controller for the host machine.
@@ -844,7 +832,7 @@
     # What Domain do we use for this host unless the individual StaticIPAddress
     # record overrides it?
     domain = ForeignKey(
-        Domain, default=get_default_domain, null=False,
+        Domain, default=get_default_domain, null=True, blank=True,
         editable=True, on_delete=PROTECT)
 
     # TTL for this Node's IP addresses.  Since this must be the same for all
@@ -904,6 +892,7 @@
     # Juju expects the following standard constraints, which are stored here
     # as a basic optimisation over querying the lshw output.
     cpu_count = IntegerField(default=0)
+    cpu_speed = IntegerField(default=0)  # MHz
     memory = IntegerField(default=0)
 
     swap_size = BigIntegerField(null=True, blank=True, default=None)
@@ -945,6 +934,11 @@
 
     license_key = CharField(max_length=30, null=True, blank=True)
 
+    # Only used by Machine. Set to True when the machine was composed
+    # dynamically from a Chassis during allocation. When the machine is
+    # released it will be deleted.
+    dynamic = BooleanField(default=False)
+
     tags = ManyToManyField(Tag)
 
     # Record the Interface the node last booted from.
@@ -1120,7 +1114,10 @@
 
         Return the FQDN for this host.
         """
-        return '%s.%s' % (self.hostname, self.domain.name)
+        if self.domain is not None:
+            return '%s.%s' % (self.hostname, self.domain.name)
+        else:
+            return self.hostname
 
     def get_deployment_time(self):
         """Return the deployment time of this node (in seconds).
@@ -1704,7 +1701,9 @@
             # Node.start() has synchronous and asynchronous parts, so catch
             # exceptions arising synchronously, and chain callbacks to the
             # Deferred it returns for the asynchronous (post-commit) bits.
-            starting = self._start(user, commissioning_user_data, old_status)
+            starting = self._start(
+                user, commissioning_user_data, old_status,
+                allow_power_cycle=True)
         except Exception as error:
             self.status = old_status
             self.save()
@@ -2098,7 +2097,11 @@
             else:
                 can_be_started = True
                 can_be_stopped = True
-            can_be_queried = power_type in QUERY_POWER_TYPES
+            power_driver = PowerDriverRegistry.get_item(power_type)
+            if power_driver is not None:
+                can_be_queried = power_driver.queryable
+            else:
+                can_be_queried = False
             return PowerInfo(
                 can_be_started, can_be_stopped, can_be_queried,
                 power_type, power_params,
@@ -2193,7 +2196,8 @@
             # Node.start() has synchronous and asynchronous parts, so catch
             # exceptions arising synchronously, and chain callbacks to the
             # Deferred it returns for the asynchronous (post-commit) bits.
-            starting = self._start(user, disk_erase_user_data, old_status)
+            starting = self._start(
+                user, disk_erase_user_data, old_status, allow_power_cycle=True)
         except Exception as error:
             # We always mark the node as failed here, although we could
             # potentially move it back to the state it was in previously. For
@@ -2378,7 +2382,7 @@
         if self.power_state == POWER_STATE.OFF:
             # The node is already powered off; we can deallocate all attached
             # resources and mark the node READY without delay.
-            release_to_ready = True
+            finalize_release = True
         elif self.get_effective_power_info().can_be_queried:
             # Controlled power type (one for which we can query the power
             # state): update_power_state() will take care of making the node
@@ -2387,13 +2391,13 @@
             post_commit().addCallback(
                 callOutToDatabase, Node._set_status_expires,
                 self.system_id, self.get_releasing_time())
-            release_to_ready = False
+            finalize_release = False
         else:
             # The node's power cannot be reliably controlled. Frankly, this
             # node is not suitable for use with MAAS. Deallocate all attached
             # resources and mark the node READY without delay because there's
             # not much else we can do.
-            release_to_ready = True
+            finalize_release = True
 
         self.status = NODE_STATUS.RELEASING
         self.token = None
@@ -2418,25 +2422,29 @@
         self.children.all().delete()
 
         # Power was off or cannot be powered off so release to ready now.
-        if release_to_ready:
-            self._release_to_ready()
+        if finalize_release:
+            self._finalize_release()
 
     @transactional
-    def _release_to_ready(self):
-        """Release all remaining resources and mark the node `READY`.
+    def _finalize_release(self):
+        """Release all remaining resources, mark the machine `READY` if not
+        dynamic, otherwise delete the machine.
 
         Releasing a node can be straightforward or it can be a multi-step
         operation, which can include a reboot in order to erase disks, then a
         final power-down. This method should be the absolute last method
         called.
         """
-        self.release_interface_config()
-        self.status = NODE_STATUS.READY
-        self.owner = None
-        self.save()
+        if self.dynamic:
+            self.delete()
+        else:
+            self.release_interface_config()
+            self.status = NODE_STATUS.READY
+            self.owner = None
+            self.save()
 
-        # Remove all set owner data.
-        OwnerData.objects.filter(node=self).delete()
+            # Remove all set owner data.
+            OwnerData.objects.filter(node=self).delete()
 
     def release_or_erase(
             self, user, comment=None,
@@ -2551,7 +2559,7 @@
         if mark_ready:
             # Ensure the node is released when it powers down.
             self.status_expires = None
-            self._release_to_ready()
+            self._finalize_release()
         if self.status == NODE_STATUS.EXITING_RESCUE_MODE:
             if self.previous_status == NODE_STATUS.BROKEN:
                 if power_state == POWER_STATE.OFF:
@@ -3074,14 +3082,18 @@
             # You can't start a node you don't own unless you're an admin.
             raise PermissionDenied()
         event = EVENT_TYPES.REQUEST_NODE_START
+        allow_power_cycle = False
         # If status is ALLOCATED, this start is actually for a deployment.
         # (Note: this is true even when nodes are being deployed from READY
         # state. See node_action.py; the node is acquired and then started.)
+        # Power cycling is allowed when deployment is being started.
         if self.status == NODE_STATUS.ALLOCATED:
             event = EVENT_TYPES.REQUEST_NODE_START_DEPLOYMENT
+            allow_power_cycle = True
         self._register_request_event(
             user, event, action='start', comment=comment)
-        return self._start(user, user_data)
+        return self._start(
+            user, user_data, allow_power_cycle=allow_power_cycle)
 
     def _get_bmc_client_connection_info(self, *args, **kwargs):
         """Return a tuple that list the rack controllers that can communicate
@@ -3114,7 +3126,9 @@
         return client_idents, fallback_idents
 
     @transactional
-    def _start(self, user, user_data=None, old_status=None):
+    def _start(
+            self, user, user_data=None, old_status=None,
+            allow_power_cycle=False):
         """Request on given user's behalf that the node be started up.
 
         :param user: Requesting user.
@@ -3171,7 +3185,10 @@
 
         # Request that the node be powered on post-commit.
         d = post_commit()
-        d = self._power_control_node(d, power_on_node, power_info)
+        if self.power_state == POWER_STATE.ON and allow_power_cycle:
+            d = self._power_control_node(d, power_cycle, power_info)
+        else:
+            d = self._power_control_node(d, power_on_node, power_info)
 
         # Set the deployment timeout so the node is marked failed after
         # a period of time.
@@ -3532,6 +3549,61 @@
             # deal with it.
             raise
 
+    def _as(self, model):
+        """Create a `model` that shares underlying storage with `self`.
+
+        In other words, the newly returned object will be an instance of
+        `model` and its `__dict__` will be `self.__dict__`. Not a copy, but a
+        reference to, so that changes to one will be reflected in the other.
+        """
+        new = object.__new__(model)
+        new.__dict__ = self.__dict__
+        return new
+
+    def as_node(self):
+        """Return a reference to self that behaves as a `Node`."""
+        return self._as(Node)
+
+    def as_machine(self):
+        """Return a reference to self that behaves as a `Machine`."""
+        return self._as(Machine)
+
+    def as_device(self):
+        """Return a reference to self that behaves as a `Device`."""
+        return self._as(Device)
+
+    def as_region_controller(self):
+        """Return a reference to self that behaves as a `RegionController`."""
+        return self._as(RegionController)
+
+    def as_rack_controller(self):
+        """Return a reference to self that behaves as a `RackController`."""
+        return self._as(RackController)
+
+    def as_chassis(self):
+        """Return a reference to self that behaves as a `Chassis`."""
+        return self._as(Chassis)
+
+    def as_storage(self):
+        """Return a reference to self that behaves as a `Storage`."""
+        return self._as(Storage)
+
+    _as_self = {
+        NODE_TYPE.DEVICE: as_device,
+        NODE_TYPE.MACHINE: as_machine,
+        NODE_TYPE.RACK_CONTROLLER: as_rack_controller,
+        # XXX ltrager 18-02-2016 - Currently only rack controllers have
+        # unique functionality so when combined return a rack controller
+        NODE_TYPE.REGION_AND_RACK_CONTROLLER: as_rack_controller,
+        NODE_TYPE.REGION_CONTROLLER: as_region_controller,
+        NODE_TYPE.CHASSIS: as_chassis,
+        NODE_TYPE.STORAGE: as_storage,
+    }
+
+    def as_self(self):
+        """Return a reference to self that behaves as its own type."""
+        return self._as_self[self.node_type](self)
+
 
 # Piston serializes objects based on the object class.
 # Here we define a proxy class so that we can specialize how devices are
@@ -4224,7 +4296,7 @@
             # If the refresh is occuring on the running region execute it using
             # the region process. This avoids using RPC and sends the node
             # results back to this host when in HA.
-            yield typecast_node(self, RegionController).refresh()
+            yield self.as_region_controller().refresh()
             return
 
         client = yield getClientFor(self.system_id, timeout=1)
@@ -4457,10 +4529,9 @@
                 % self.hostname)
 
         if self.node_type == NODE_TYPE.REGION_AND_RACK_CONTROLLER:
-            # typecast_to_node_type returns a RackController object when the
-            # node is a REGION_AND_RACK_CONTROLLER. Thus the API and websocket
-            # will transition a REGION_AND_RACK_CONTROLLER to a
-            # REGION_CONTROLLER.
+            # Node.as_self() returns a RackController object when the node is
+            # a REGION_AND_RACK_CONTROLLER. Thus the API and websocket will
+            # transition a REGION_AND_RACK_CONTROLLER to a REGION_CONTROLLER.
             self.node_type = NODE_TYPE.RACK_CONTROLLER
             self.save()
         elif self._was_probably_machine():
@@ -4519,6 +4590,56 @@
         pass
 
 
+class Chassis(Node):
+    """A node that contains multiple machines and can compose new machines."""
+
+    objects = ChassisManager()
+
+    class Meta(DefaultMeta):
+        proxy = True
+
+    def __init__(self, *args, **kwargs):
+        super(Chassis, self).__init__(
+            node_type=NODE_TYPE.CHASSIS, *args, **kwargs)
+
+    def clean_architecture(self, prev):
+        # Chassis aren't required to have a defined architecture
+        pass
+
+    def clean_hostname_domain(self, prev):
+        # Chassis is never in a domain.
+        if self.hostname.find('.') > -1:
+            # They have specified an FQDN.  Split up the pieces, and throw
+            # away the rest.
+            self.hostname, _ = self.hostname.split('.', 1)
+        self.domain = None
+
+
+class Storage(Node):
+    """A node that provides storage to other machines."""
+
+    objects = StorageManager()
+
+    class Meta(DefaultMeta):
+        proxy = True
+
+    def __init__(self, *args, **kwargs):
+        super(Storage, self).__init__(
+            node_type=NODE_TYPE.STORAGE, *args, **kwargs)
+
+    def clean_architecture(self, prev):
+        # Storage aren't required to have a defined architecture
+        pass
+
+    def clean_hostname_domain(self, prev):
+        # Storage is never in a domain.
+        if self.hostname.find('.') > -1:
+            # They have specified an FQDN.  Split up the pieces, and throw
+            # away the rest.
+            self.hostname, _ = self.hostname.split('.', 1)
+        self.domain = None
+
+
 class NodeGroupToRackController(CleanSave, Model):
     """Store some of the old NodeGroup data so we can migrate it when a rack
     controller is registered.
 
=== modified file 'src/maasserver/models/signals/nodes.py'
--- src/maasserver/models/signals/nodes.py	2016-08-16 09:31:16 +0000
+++ src/maasserver/models/signals/nodes.py	2016-12-07 15:50:52 +0000
@@ -12,8 +12,12 @@
     post_save,
     pre_save,
 )
-from maasserver.enum import NODE_STATUS
+from maasserver.enum import (
+    NODE_STATUS,
+    NODE_TYPE,
+)
 from maasserver.models import (
+    ChassisHints,
     Controller,
     Device,
     Machine,
@@ -105,5 +109,23 @@
         sender=klass)
 
 
+def create_chassis_hints(sender, instance, created, **kwargs):
+    """Create `ChassisHints` when `Chassis` is created."""
+    try:
+        chassis_hints = instance.chassis_hints
+    except ChassisHints.DoesNotExist:
+        chassis_hints = None
+    if instance.node_type == NODE_TYPE.CHASSIS:
+        if chassis_hints is None:
+            ChassisHints.objects.create(chassis=instance)
+    elif chassis_hints is not None:
+        chassis_hints.delete()
+
+for klass in NODE_CLASSES:
+    signals.watch(
+        post_save, create_chassis_hints,
+        sender=klass)
+
+
 # Enable all signals by default.
 signals.enable()
 
=== modified file 'src/maasserver/models/signals/tests/test_nodes.py'
--- src/maasserver/models/signals/tests/test_nodes.py	2016-09-07 14:23:05 +0000
+++ src/maasserver/models/signals/tests/test_nodes.py	2016-12-07 15:50:52 +0000
@@ -11,6 +11,7 @@
     NODE_STATUS,
     NODE_TYPE,
 )
+from maasserver.models import ChassisHints
 from maasserver.models.service import (
     RACK_SERVICES,
     REGION_SERVICES,
@@ -144,3 +145,27 @@
         self.assertThat(
             {service.name for service in services},
             Equals(REGION_SERVICES))
+
+
+class TestCreateChassisHints(MAASServerTestCase):
+
+    def test_creates_hints_for_chassis(self):
+        chassis = factory.make_Node(node_type=NODE_TYPE.CHASSIS)
+        self.assertIsNotNone(chassis.chassis_hints)
+
+    def test_creates_hints_device_converted_to_chassis(self):
+        device = factory.make_Device()
+        device.node_type = NODE_TYPE.CHASSIS
+        device.save()
+        self.assertIsNotNone(device.chassis_hints)
+
+    def test_deletes_hints_when_chassis_converted_to_device(self):
+        chassis = factory.make_Node(node_type=NODE_TYPE.CHASSIS)
+        chassis.node_type = NODE_TYPE.DEVICE
+        chassis.save()
+        error = None
+        try:
+            reload_object(chassis).chassis_hints
+        except ChassisHints.DoesNotExist as exc:
+            error = exc
+        self.assertIsNotNone(error)
 
=== modified file 'src/maasserver/models/staticipaddress.py'
--- src/maasserver/models/staticipaddress.py	2016-11-17 18:53:03 +0000
+++ src/maasserver/models/staticipaddress.py	2016-12-07 15:50:52 +0000
@@ -50,19 +50,10 @@
 from maasserver.models.domain import Domain
 from maasserver.models.subnet import Subnet
 from maasserver.models.timestampedmodel import TimestampedModel
+from maasserver.utils import orm
 from maasserver.utils.dns import get_ip_based_hostname
-from maasserver.utils.orm import (
-    request_transaction_retry,
-    transactional,
-)
-from maasserver.utils.threads import deferToDatabase
 from netaddr import IPAddress
-from provisioningserver.logger import get_maas_logger
 from provisioningserver.utils.enum import map_enum_reverse
-from provisioningserver.utils.twisted import asynchronous
-
-
-maaslog = get_maas_logger("node")
 
 
 class HostnameIPMapping:
@@ -144,15 +135,13 @@
         :return: `StaticIPAddress` if successful.
         :raise StaticIPAddressUnavailable: if the address was already taken.
         """
-        ipaddress = StaticIPAddress(
-            ip=requested_address.format(), alloc_type=alloc_type,
-            subnet=subnet)
-        ipaddress.set_ip_address(requested_address.format())
+        ipaddress = StaticIPAddress(alloc_type=alloc_type, subnet=subnet)
         try:
             # Try to save this address to the database. Do this in a nested
             # transaction so that we can continue using the outer transaction
             # even if this breaks.
             with transaction.atomic():
+                ipaddress.set_ip_address(requested_address.format())
                 ipaddress.save()
         except IntegrityError:
             # The address is already taken.
@@ -168,6 +157,55 @@
             ipaddress.save()
             return ipaddress
 
+    def _attempt_allocation_of_free_address(
+            self, requested_address, alloc_type, user=None, subnet=None):
+        """Attempt to allocate `requested_address`, which is known to be free.
+
+        It is known to be free *in this transaction*, so this could still
+        fail. If it does fail because of a `UNIQUE_VIOLATION` it will request
+        a retry, except while holding an addition lock. This is not perfect:
+        other threads could jump in before acquiring the lock and steal an
+        apparently free address. However, in stampede situations this appears
+        to be effective enough. Experiment by increasing the `count` parameter
+        in `test_allocate_new_works_under_extreme_concurrency`.
+
+        This method shares a lot in common with `_attempt_allocation` so check
+        out its documentation for more details.
+
+        :param requested_address: The address to be allocated.
+        :typr requested_address: IPAddress
+        :param alloc_type: Allocation type.
+        :param user: Optional user.
+        :return: `StaticIPAddress` if successful.
+        :raise RetryTransaction: if the address was already taken.
+        """
+        ipaddress = StaticIPAddress(alloc_type=alloc_type, subnet=subnet)
+        try:
+            # Try to save this address to the database. Do this in a nested
+            # transaction so that we can continue using the outer transaction
+            # even if this breaks.
+            with orm.savepoint():
+                ipaddress.set_ip_address(requested_address.format())
+                ipaddress.save()
+        except IntegrityError as error:
+            if orm.is_unique_violation(error):
+                # The address is taken. We could allow the transaction retry
+                # machinery to take care of this, but instead we'll ask it to
+                # retry with the `address_allocation` lock. We can't take it
+                # here because we're already in a transaction; we need to exit
+                # the transaction, take the lock, and only then try again.
+                orm.request_transaction_retry(locks.address_allocation)
+            else:
+                raise
+        else:
+            # We deliberately do *not* save the user until now because it
+            # might result in an IntegrityError, and we rely on the latter
+            # in the code above to indicate an already allocated IP
+            # address and nothing else.
+            ipaddress.user = user
+            ipaddress.save()
+            return ipaddress
+
     def allocate_new(
             self, subnet=None, alloc_type=IPADDRESS_TYPE.AUTO, user=None,
             requested_address=None, exclude_addresses=[]):
@@ -185,9 +223,6 @@
         :param exclude_addresses: A list of addresses which MUST NOT be used.
 
         All IP parameters can be strings or netaddr.IPAddress.
-
-        Note that this method has been designed to work even when the database
-        is running with READ COMMITTED isolation. Try to keep it that way.
         """
         # This check for `alloc_type` is important for later on. We rely on
         # detecting IntegrityError as a sign than an IP address is already
@@ -203,21 +238,15 @@
                     "Could not find an appropriate subnet.")
 
         if requested_address is None:
-            with locks.staticip_acquire:
-                requested_address = self._async_find_free_ip(
-                    subnet, exclude_addresses=exclude_addresses).wait(30)
-                try:
-                    return self._attempt_allocation(
-                        requested_address, alloc_type, user,
-                        subnet=subnet)
-                except StaticIPAddressUnavailable:
-                    # We lost the race: another transaction has taken this IP
-                    # address. Retry this transaction from the top.
-                    request_transaction_retry()
+            requested_address = subnet.get_next_ip_for_allocation(
+                exclude_addresses=exclude_addresses)
+            return self._attempt_allocation_of_free_address(
+                requested_address, alloc_type, user=user, subnet=subnet)
         else:
             requested_address = IPAddress(requested_address)
             subnet.validate_static_ip(requested_address)
             return self._attempt_allocation(
+<<<<<<< TREE
                 requested_address, alloc_type,
                 user=user, subnet=subnet)
 
@@ -375,6 +404,156 @@
 
     def _find_free_ip(self, subnet, exclude_addresses=None):
         return subnet.get_next_ip_for_allocation(exclude_addresses)
+=======
+                requested_address, alloc_type, user=user, subnet=subnet)
+
+    def _get_special_mappings(self, domain, raw_ttl=False):
+        """Get the special mappings, possibly limited to a single Domain.
+
+        This function is responsible for creating these mappings:
+        - any USER_RESERVED IP,
+        - any IP not associated with a Node,
+        - any IP associated with a DNSResource.
+        The caller is responsible for addresses otherwise derived from nodes.
+
+        Because of how the get hostname_ip_mapping code works, we actually need
+        to fetch ALL of the entries for subnets, but forward mappings need to
+        be domain-specific.
+
+        :param domain: limit return to just the given Domain.  If anything
+            other than a Domain is passed in (e.g., a Subnet or None), we
+            return all of the reverse mappings.
+        :param raw_ttl: Boolean, if True then just return the address_ttl,
+            otherwise, coalesce the address_ttl to be the correct answer for
+            zone generation.
+        :return: a (default) dict of hostname: HostnameIPMapping entries.
+        """
+        default_ttl = "%d" % Config.objects.get_config('default_dns_ttl')
+        if isinstance(domain, Domain):
+            # Domains are special in that we only want to have entries for the
+            # domain that we were asked about.  And they can possibly come from
+            # either the child or the parent for glue.
+            where_clause = """
+                AND (
+                    dnsrr.dom2_id = %s OR
+                    node.dom2_id = %s OR
+                    dnsrr.domain_id = %s OR
+                    node.domain_id = %s
+            """
+            query_parms = [domain.id, domain.id, domain.id, domain.id]
+            # And the default domain is extra special, since it needs to have
+            # A/AAAA RRs for any USER_RESERVED addresses that have no name
+            # otherwise attached to them.
+            if domain.is_default():
+                where_clause += """ OR (
+                    dnsrr.fqdn IS NULL AND
+                    node.fqdn IS NULL)
+                """
+            where_clause += ")"
+        else:
+            # There is nothing special about the query for subnets.
+            domain = None
+            where_clause = ""
+            query_parms = []
+        # raw_ttl says that we don't coalesce, but we need to pick one, so we
+        # go with DNSResource if it is involved.
+        if raw_ttl:
+            ttl_clause = """COALESCE(dnsrr.address_ttl, node.address_ttl)"""
+        else:
+            ttl_clause = """
+                COALESCE(
+                    dnsrr.address_ttl,
+                    dnsrr.ttl,
+                    node.address_ttl,
+                    node.ttl,
+                    %s)""" % default_ttl
+        # And here is the SQL query of doom.  Build up inner selects to get the
+        # view of a DNSResource (and Node) that we need, and finally use
+        # domain2 to handle the case where an FQDN is also the name of a domain
+        # that we know.
+        sql_query = """
+            SELECT
+                COALESCE(dnsrr.fqdn, node.fqdn) AS fqdn,
+                node.system_id,
+                node.node_type,
+                """ + ttl_clause + """ AS ttl,
+                staticip.ip
+            FROM
+                maasserver_staticipaddress AS staticip
+            LEFT JOIN (
+                /* Create a dnsrr that has what we need. */
+                SELECT
+                    CASE WHEN dnsrr.name = '@' THEN
+                        dom.name
+                    ELSE
+                        CONCAT(dnsrr.name, '.', dom.name)
+                    END AS fqdn,
+                    dom.name as dom_name,
+                    dnsrr.domain_id,
+                    dnsrr.address_ttl,
+                    dom.ttl,
+                    dia.staticipaddress_id AS dnsrr_sip_id,
+                    dom2.id AS dom2_id
+                FROM maasserver_dnsresource_ip_addresses AS dia
+                JOIN maasserver_dnsresource AS dnsrr ON
+                    dia.dnsresource_id = dnsrr.id
+                JOIN maasserver_domain AS dom ON
+                    dnsrr.domain_id = dom.id
+                LEFT JOIN maasserver_domain AS dom2 ON
+                    CONCAT(dnsrr.name, '.', dom.name) = dom2.name OR (
+                        dnsrr.name = '@' AND
+                        dom.name SIMILAR TO CONCAT('[-A-Za-z0-9]*.', dom2.name)
+                    )
+                ) AS dnsrr ON
+                    dnsrr_sip_id = staticip.id
+            LEFT JOIN (
+                /* Create a node that has what we need. */
+                SELECT
+                    CONCAT(nd.hostname, '.', dom.name) AS fqdn,
+                    dom.name as dom_name,
+                    nd.system_id,
+                    nd.node_type,
+                    nd.domain_id,
+                    nd.address_ttl,
+                    dom.ttl,
+                    iia.staticipaddress_id AS node_sip_id,
+                    dom2.id AS dom2_id
+                FROM maasserver_interface_ip_addresses AS iia
+                JOIN maasserver_interface AS iface ON
+                    iia.interface_id = iface.id
+                JOIN maasserver_node AS nd ON
+                    iface.node_id = nd.id
+                JOIN maasserver_domain AS dom ON
+                    nd.domain_id = dom.id
+                LEFT JOIN maasserver_domain AS dom2 ON
+                    CONCAT(nd.hostname, '.', dom.name) = dom2.name
+                ) AS node ON
+                    node_sip_id = staticip.id
+            WHERE
+                staticip.ip IS NOT NULL AND
+                host(staticip.ip) != '' AND
+                (
+                    staticip.alloc_type = %s OR
+                    node.fqdn IS NULL OR
+                    dnsrr IS NOT NULL
+                )""" + where_clause + """
+        """
+        default_domain = Domain.objects.get_default_domain()
+        mapping = defaultdict(HostnameIPMapping)
+        cursor = connection.cursor()
+        query_parms = [IPADDRESS_TYPE.USER_RESERVED] + query_parms
+        cursor.execute(sql_query, query_parms)
+        for (fqdn, system_id, node_type, ttl,
+                ip) in cursor.fetchall():
+            if fqdn is None or fqdn == '':
+                fqdn = "%s.%s" % (
+                    get_ip_based_hostname(ip), default_domain.name)
+            mapping[fqdn].node_type = node_type
+            mapping[fqdn].system_id = system_id
+            mapping[fqdn].ttl = ttl
+            mapping[fqdn].ips.add(ip)
+        return mapping
+>>>>>>> MERGE-SOURCE
 
     def get_hostname_ip_mapping(self, domain_or_subnet, raw_ttl=False):
         """Return hostname mappings for `StaticIPAddress` entries.
 
=== modified file 'src/maasserver/models/subnet.py'
--- src/maasserver/models/subnet.py	2016-10-18 16:48:13 +0000
+++ src/maasserver/models/subnet.py	2016-12-07 15:50:52 +0000
@@ -59,6 +59,7 @@
 )
 from provisioningserver.logger import get_maas_logger
 from provisioningserver.utils.network import (
+    IPRANGE_TYPE as MAASIPRANGE_TYPE,
     MAASIPSet,
     make_ipaddress,
     make_iprange,
@@ -386,6 +387,9 @@
     active_discovery = BooleanField(
         editable=True, blank=False, null=False, default=False)
 
+    managed = BooleanField(
+        editable=True, blank=False, null=False, default=True)
+
     @property
     def label(self):
         """Returns a human-friendly label for this subnet."""
@@ -474,7 +478,8 @@
 
     def get_ipranges_in_use(
             self, exclude_addresses: IPAddressExcludeList=None,
-            ranges_only: bool=False,
+            ranges_only: bool=False, include_reserved: bool=True,
+            with_neighbours: bool=False,
             ignore_discovered_ips: bool=False) -> MAASIPSet:
         """Returns a `MAASIPSet` of `MAASIPRange` objects which are currently
         in use on this `Subnet`.
@@ -483,6 +488,8 @@
         :param ignore_discovered_ips: DISCOVERED addresses are not "in use".
         :param ranges_only: if True, filters out gateway IPs, static routes,
             DNS servers, and `exclude_addresses`.
+        :param with_neighbours: If True, includes addresses learned from
+            neighbour observation.
         """
         if exclude_addresses is None:
             exclude_addresses = []
@@ -531,8 +538,11 @@
                 for address in exclude_addresses
                 if address in network
             )
-        ranges |= self.get_reserved_maasipset()
+        if include_reserved:
+            ranges |= self.get_reserved_maasipset()
         ranges |= self.get_dynamic_maasipset()
+        if with_neighbours:
+            ranges |= self.get_maasipset_for_neighbours()
         return MAASIPSet(ranges)
 
     def get_ipranges_available_for_reserved_range(self):
@@ -549,19 +559,71 @@
         """Returns a `MAASIPSet` of ranges which are currently free on this
         `Subnet`.
 
+        :param ranges_only: if True, filters out gateway IPs, static routes,
+            DNS servers, and `exclude_addresses`.
         :param exclude_addresses: An iterable of addresses not to use.
         :param ignore_discovered_ips: DISCOVERED addresses are not "in use".
+        :param with_neighbours: If True, includes addresses learned from
+            neighbour observation.
         """
         if exclude_addresses is None:
             exclude_addresses = []
-        ranges = self.get_ipranges_in_use(
+        in_use = self.get_ipranges_in_use(
             exclude_addresses=exclude_addresses,
             ranges_only=ranges_only,
+            with_neighbours=with_neighbours,
             ignore_discovered_ips=ignore_discovered_ips)
-        if with_neighbours:
-            ranges |= self.get_maasipset_for_neighbours()
-        unused = ranges.get_unused_ranges(self.get_ipnetwork())
-        return unused
+        if self.managed or ranges_only:
+            not_in_use = in_use.get_unused_ranges(self.get_ipnetwork())
+        else:
+            # The end result we want is a list of unused IP addresses *within*
+            # reserved ranges. To get that result, we first need the full list
+            # of unused IP addresses on the subnet. This is better illustrated
+            # visually below.
+            #
+            # Legend:
+            #     X:  in-use IP addresses
+            #     R:  reserved range
+            #     Rx: reserved range (with allocated, in-use IP address)
+            #
+            #             +----+----+----+----+----+----+
+            # IP address: | 1  | 2  | 3  | 4  | 5  | 6  |
+            #             +----+----+----+----+----+----+
+            #     Usages: | X  |    | R  | Rx |    | X  |
+            #             +----+----+----+----+----+----+
+            #
+            # We need a set that just contains `3` in this case. To get there,
+            # first calculate the set of all unused addresses on the subnet,
+            # then intersect that set with set of in-use addresses *excluding*
+            # the reserved range, then calculate which addresses within *that*
+            # set are unused:
+            #                               +----+----+----+----+----+----+
+            #                   IP address: | 1  | 2  | 3  | 4  | 5  | 6  |
+            #                               +----+----+----+----+----+----+
+            #                       unused: |    | U  |    |    | U  |    |
+            #                               +----+----+----+----+----+----+
+            #             unmanaged_in_use: | u  |    |    | u  |    | u  |
+            #                               +----+----+----+----+----+----+
+            #                 |= unmanaged: ===============================
+            #                               +----+----+----+----+----+----+
+            #             unmanaged_in_use: | u  | U  |    | u  | U  | u  |
+            #                               +----+----+----+----+----+----+
+            #          get_unused_ranges(): ===============================
+            #                               +----+----+----+----+----+----+
+            #                   not_in_use: |    |    | n  |    |    |    |
+            #                               +----+----+----+----+----+----+
+            unused = in_use.get_unused_ranges(
+                self.get_ipnetwork(), purpose=MAASIPRANGE_TYPE.UNMANAGED)
+            unmanaged_in_use = self.get_ipranges_in_use(
+                exclude_addresses=exclude_addresses,
+                ranges_only=ranges_only,
+                include_reserved=False,
+                with_neighbours=with_neighbours,
+                ignore_discovered_ips=ignore_discovered_ips)
+            unmanaged_in_use |= unused
+            not_in_use = unmanaged_in_use.get_unused_ranges(
+                self.get_ipnetwork(), purpose=MAASIPRANGE_TYPE.UNUSED)
+        return not_in_use
 
     def get_maasipset_for_neighbours(self) -> MAASIPSet:
         """Return the observed neighbours in this subnet.
 
=== modified file 'src/maasserver/models/tests/test_discovery.py'
--- src/maasserver/models/tests/test_discovery.py	2016-11-02 20:18:07 +0000
+++ src/maasserver/models/tests/test_discovery.py	2016-12-07 15:50:52 +0000
@@ -16,6 +16,7 @@
 from maasserver.testing.testcase import MAASServerTestCase
 from maastesting.matchers import (
     DocTestMatches,
+    IsNonEmptyString,
     Matches,
     MockCalledOnceWith,
     MockNotCalled,
@@ -34,7 +35,7 @@
 
     def test_mac_organization(self):
         discovery = factory.make_Discovery(mac_address="48:51:b7:00:00:00")
-        self.assertThat(discovery.mac_organization, Equals("Intel Corporate"))
+        self.assertThat(discovery.mac_organization, IsNonEmptyString)
 
     def test__ignores_duplicate_macs(self):
         rack1 = factory.make_RackController()
 
=== modified file 'src/maasserver/models/tests/test_event.py'
--- src/maasserver/models/tests/test_event.py	2015-12-01 18:12:59 +0000
+++ src/maasserver/models/tests/test_event.py	2016-12-07 15:50:52 +0000
@@ -11,6 +11,7 @@
 from django.db import IntegrityError
 from maasserver.models import (
     Event,
+    event as event_module,
     EventType,
 )
 from maasserver.testing.factory import factory
@@ -84,6 +85,15 @@
         self.assertIsNotNone(EventType.objects.get(name=event_type))
         self.assertIsNotNone(Event.objects.get(node=node))
 
+    def test_create_region_event_creates_region_event(self):
+        region = factory.make_RegionRackController()
+        self.patch(event_module, 'get_maas_id').return_value = region.system_id
+        Event.objects.create_region_event(
+            event_type=EVENT_TYPES.REGION_IMPORT_ERROR)
+        self.assertIsNotNone(
+            EventType.objects.get(name=EVENT_TYPES.REGION_IMPORT_ERROR))
+        self.assertIsNotNone(Event.objects.get(node=region))
+
     def test_register_event_and_event_type_handles_integrity_errors(self):
         # It's possible that two calls to
         # register_event_and_event_type() could arrive at more-or-less
 
=== modified file 'src/maasserver/models/tests/test_neighbour.py'
--- src/maasserver/models/tests/test_neighbour.py	2016-08-19 11:40:52 +0000
+++ src/maasserver/models/tests/test_neighbour.py	2016-12-07 15:50:52 +0000
@@ -7,11 +7,11 @@
 
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
-from testtools.matchers import Equals
+from maastesting.matchers import IsNonEmptyString
 
 
 class TestNeighbourModel(MAASServerTestCase):
 
     def test_mac_organization(self):
         neighbour = factory.make_Neighbour(mac_address="48:51:b7:00:00:00")
-        self.assertThat(neighbour.mac_organization, Equals("Intel Corporate"))
+        self.assertThat(neighbour.mac_organization, IsNonEmptyString)
 
=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2016-12-07 11:26:49 +0000
+++ src/maasserver/models/tests/test_node.py	2016-12-07 15:50:52 +0000
@@ -60,6 +60,7 @@
     BondInterface,
     BootResource,
     BridgeInterface,
+    Chassis,
     Config,
     Controller,
     Device,
@@ -78,6 +79,7 @@
     RegionRackRPCConnection,
     Service,
     Space,
+    Storage,
     Subnet,
     UnknownInterface,
     VLAN,
@@ -95,8 +97,6 @@
     GatewayDefinition,
     generate_node_system_id,
     PowerInfo,
-    typecast_node,
-    typecast_to_node_type,
 )
 from maasserver.models.signals import power as node_query
 from maasserver.models.timestampedmodel import now
@@ -137,6 +137,7 @@
 from maasserver.worker_user import get_worker_user
 from maastesting.matchers import (
     DocTestMatches,
+    IsNonEmptyString,
     MockCalledOnce,
     MockCalledOnceWith,
     MockCallsMatch,
@@ -154,12 +155,11 @@
     disk_erasing,
 )
 from netaddr import IPAddress
+from provisioningserver.drivers.power import PowerDriverRegistry
 from provisioningserver.events import (
     EVENT_DETAILS,
     EVENT_TYPES,
 )
-from provisioningserver.power import QUERY_POWER_TYPES
-from provisioningserver.power.schema import JSON_POWER_TYPE_PARAMETERS
 from provisioningserver.rpc.cluster import (
     AddChassis,
     DisableAndShutoffRackd,
@@ -225,59 +225,86 @@
             "... after 1000 iterations ... no unused node identifiers."))
 
 
-class TestTypeCastNode(MAASServerTestCase):
-    def test_all_node_types_can_be_casted(self):
-        node = factory.make_Node()
-        cast_to = random.choice(
-            [Device, Machine, Node, RackController, RegionController])
-        typecast_node(node, cast_to)
-        self.assertIsInstance(node, cast_to)
-
-    def test_rejects_casting_to_non_node_type_objects(self):
-        node = factory.make_Node()
-        self.assertRaises(AssertionError, typecast_node, node, object)
-
-    def test_rejects_casting_non_node_type(self):
-        node = object()
-        cast_to = random.choice(
-            [Device, Machine, Node, RackController, RegionController])
-        self.assertRaises(AssertionError, typecast_node, node, cast_to)
-
-    def test_sets_hostname_if_blank(self):
-        node = factory.make_Node(hostname='')
-        self.assertNotEqual('', node.hostname)
+def HasType(type_):
+    return AfterPreprocessing(type, Is(type_), annotate=False)
+
+
+def SharesStorageWith(other):
+    return AfterPreprocessing(
+        (lambda thing: thing.__dict__), Is(other.__dict__),
+        annotate=False)
 
 
 class TestTypeCastToNodeType(MAASServerTestCase):
+
+    def test_cast_to_self(self):
+        node = factory.make_Node().as_node()
+        node_types = set(map_enum(NODE_TYPE).values())
+        casts = {
+            NODE_TYPE.DEVICE: Device,
+            NODE_TYPE.MACHINE: Machine,
+            NODE_TYPE.RACK_CONTROLLER: RackController,
+            NODE_TYPE.REGION_AND_RACK_CONTROLLER: RackController,
+            NODE_TYPE.REGION_CONTROLLER: RegionController,
+            NODE_TYPE.CHASSIS: Chassis,
+            NODE_TYPE.STORAGE: Storage,
+        }
+        self.assertThat(casts.keys(), Equals(node_types))
+        for node_type, cast_type in casts.items():
+            node.node_type = node_type
+            node_as_self = node.as_self()
+            self.assertThat(node, HasType(Node))
+            self.assertThat(node_as_self, HasType(cast_type))
+            self.assertThat(node_as_self, SharesStorageWith(node))
+
     def test_cast_to_machine(self):
-        node = factory.make_Node(node_type=NODE_TYPE.MACHINE)
-        machine = typecast_to_node_type(node)
-        self.assertIsInstance(machine, Machine)
+        node = factory.make_Node().as_node()
+        machine = node.as_machine()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(machine, HasType(Machine))
+        self.assertThat(machine, SharesStorageWith(node))
 
     def test_cast_to_rack_controller(self):
-        node = factory.make_Node(node_type=NODE_TYPE.RACK_CONTROLLER)
-        rack = typecast_to_node_type(node)
-        self.assertIsInstance(rack, RackController)
-
-    def test_cast_to_region_and_rack_controller(self):
-        node = factory.make_Node(
-            node_type=NODE_TYPE.REGION_AND_RACK_CONTROLLER)
-        rack = typecast_to_node_type(node)
-        self.assertIsInstance(rack, RackController)
+        node = factory.make_Node().as_node()
+        rack = node.as_rack_controller()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(rack, HasType(RackController))
+        self.assertThat(rack, SharesStorageWith(node))
 
     def test_cast_to_region_controller(self):
-        node = factory.make_Node(node_type=NODE_TYPE.REGION_CONTROLLER)
-        region = typecast_to_node_type(node)
-        self.assertIsInstance(region, RegionController)
+        node = factory.make_Node().as_node()
+        region = node.as_region_controller()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(region, HasType(RegionController))
+        self.assertThat(region, SharesStorageWith(node))
 
     def test_cast_to_device(self):
-        node = factory.make_Node(node_type=NODE_TYPE.DEVICE)
-        device = typecast_to_node_type(node)
-        self.assertIsInstance(device, Device)
-
-    def test_throws_exception_on_unknown_type(self):
-        node = factory.make_Node(node_type=random.randint(10, 10000))
-        self.assertRaises(NotImplementedError, typecast_to_node_type, node)
+        node = factory.make_Node().as_node()
+        device = node.as_device()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(device, HasType(Device))
+        self.assertThat(device, SharesStorageWith(node))
+
+    def test_cast_to_node(self):
+        machine = factory.make_Machine()
+        node = machine.as_node()
+        self.assertThat(machine, HasType(Machine))
+        self.assertThat(node, HasType(Node))
+        self.assertThat(node, SharesStorageWith(machine))
+
+    def test_cast_to_chassis(self):
+        node = factory.make_Node().as_node()
+        chassis = node.as_chassis()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(chassis, HasType(Chassis))
+        self.assertThat(chassis, SharesStorageWith(node))
+
+    def test_cast_to_storage(self):
+        node = factory.make_Node().as_node()
+        storage = node.as_storage()
+        self.assertThat(node, HasType(Node))
+        self.assertThat(storage, HasType(Storage))
+        self.assertThat(storage, SharesStorageWith(node))
 
 
 class TestNodeManager(MAASServerTestCase):
@@ -1229,12 +1256,11 @@
                  sentinel.power_parameters), node.get_effective_power_info())
 
     def test_get_effective_power_info_cant_be_queried(self):
-        all_power_types = {
-            power_type_details['name']
-            for power_type_details in JSON_POWER_TYPE_PARAMETERS
-        }
-        uncontrolled_power_types = all_power_types.difference(
-            QUERY_POWER_TYPES)
+        uncontrolled_power_types = [
+            driver.name
+            for _, driver in PowerDriverRegistry
+            if not driver.queryable
+        ]
         for power_type in uncontrolled_power_types:
             node = factory.make_Node(power_type=power_type)
             gepp = self.patch(node, "get_effective_power_parameters")
@@ -1245,7 +1271,11 @@
                 node.get_effective_power_info())
 
     def test_get_effective_power_info_can_be_queried(self):
-        power_type = random.choice(QUERY_POWER_TYPES)
+        power_type = random.choice([
+            driver.name
+            for _, driver in PowerDriverRegistry
+            if driver.queryable
+        ])
         node = factory.make_Node(power_type=power_type)
         gepp = self.patch(node, "get_effective_power_parameters")
         self.assertEqual(
@@ -1499,7 +1529,8 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         Config.objects.set_config('disk_erase_with_secure_erase', True)
         Config.objects.set_config('disk_erase_with_quick_erase', True)
         with post_commit_hooks:
@@ -1521,7 +1552,8 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         Config.objects.set_config('disk_erase_with_secure_erase', False)
         Config.objects.set_config('disk_erase_with_quick_erase', False)
         with post_commit_hooks:
@@ -1543,14 +1575,17 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         with post_commit_hooks:
             node.start_disk_erasing(owner)
         self.expectThat(node.owner, Equals(owner))
         self.expectThat(node.status, Equals(NODE_STATUS.DISK_ERASING))
         self.expectThat(node.agent_name, Equals(agent_name))
         self.assertThat(
-            node_start, MockCalledOnceWith(owner, ANY, NODE_STATUS.ALLOCATED))
+            node_start,
+            MockCalledOnceWith(
+                owner, ANY, NODE_STATUS.ALLOCATED, allow_power_cycle=True))
 
     def test_start_disk_erasing_logs_user_request(self):
         owner = factory.make_User()
@@ -1558,12 +1593,15 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         register_event = self.patch(node, '_register_request_event')
         with post_commit_hooks:
             node.start_disk_erasing(owner)
         self.assertThat(
-            node_start, MockCalledOnceWith(owner, ANY, NODE_STATUS.ALLOCATED))
+            node_start,
+            MockCalledOnceWith(
+                owner, ANY, NODE_STATUS.ALLOCATED, allow_power_cycle=True))
         self.assertThat(register_event, MockCalledOnceWith(
             owner, EVENT_TYPES.REQUEST_NODE_ERASE_DISK,
             action='start disk erasing', comment=None))
@@ -1626,7 +1664,8 @@
 
         self.assertThat(
             node_start, MockCalledOnceWith(
-                admin, generate_user_data.return_value, NODE_STATUS.ALLOCATED))
+                admin, generate_user_data.return_value, NODE_STATUS.ALLOCATED,
+                allow_power_cycle=True))
         self.assertEqual(NODE_STATUS.FAILED_DISK_ERASING, node.status)
 
     def test_start_disk_erasing_sets_status_on_post_commit_error(self):
@@ -1807,20 +1846,18 @@
         }
         # Use an "uncontrolled" power type (i.e. a power type for which we
         # cannot query the status of the node).
-        all_power_types = {
-            power_type_details['name']
-            for power_type_details in JSON_POWER_TYPE_PARAMETERS
-        }
-        uncontrolled_power_types = (
-            all_power_types.difference(QUERY_POWER_TYPES))
-        power_type = random.choice(list(uncontrolled_power_types))
+        power_type = random.choice([
+            driver.name
+            for _, driver in PowerDriverRegistry
+            if not driver.queryable
+        ])
         rack = factory.make_RackController()
         node = factory.make_Node_with_Interface_on_Subnet(
             status=NODE_STATUS.ALLOCATED, owner=owner, owner_data=owner_data,
             agent_name=agent_name, power_type=power_type, primary_rack=rack)
         self.patch(Node, '_set_status_expires')
         mock_stop = self.patch(node, "_stop")
-        mock_release_to_ready = self.patch(node, "_release_to_ready")
+        mock_finalize_release = self.patch(node, "_finalize_release")
         node.power_state = POWER_STATE.ON
         node.release()
         self.expectThat(Node._set_status_expires, MockNotCalled())
@@ -1833,7 +1870,7 @@
         self.expectThat(node.distro_series, Equals(''))
         self.expectThat(node.license_key, Equals(''))
         self.expectThat(mock_stop, MockCalledOnceWith(node.owner))
-        self.expectThat(mock_release_to_ready, MockCalledOnceWith())
+        self.expectThat(mock_finalize_release, MockCalledOnceWith())
 
     def test_release_node_that_has_power_off(self):
         agent_name = factory.make_name('agent-name')
@@ -1879,6 +1916,16 @@
             [], list(NodeResult.objects.filter(
                 node=node, result_type=RESULT_TYPE.INSTALLATION)))
 
+    def test_release_deletes_dynamic_machine(self):
+        agent_name = factory.make_name('agent-name')
+        owner = factory.make_User()
+        node = factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=owner, agent_name=agent_name,
+            dynamic=True, power_state=POWER_STATE.OFF)
+        with post_commit_hooks:
+            node.release()
+        self.assertIsNone(reload_object(node))
+
     def test_dynamic_ip_addresses_from_ip_address_table(self):
         node = factory.make_Node()
         interfaces = [
@@ -2233,7 +2280,8 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         admin = factory.make_admin()
         node.start_commissioning(admin)
         post_commit_hooks.reset()  # Ignore these for now.
@@ -2243,7 +2291,7 @@
         }
         self.assertAttributes(node, expected_attrs)
         self.assertThat(node_start, MockCalledOnceWith(
-            admin, ANY, NODE_STATUS.NEW))
+            admin, ANY, NODE_STATUS.NEW, allow_power_cycle=True))
 
     def test_start_commissioning_sets_options(self):
         rack = factory.make_RackController()
@@ -2253,7 +2301,8 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         admin = factory.make_admin()
         enable_ssh = factory.pick_bool()
         skip_networking = factory.pick_bool()
@@ -2274,7 +2323,8 @@
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         user_data = factory.make_string().encode('ascii')
         generate_user_data = self.patch(
             commissioning, 'generate_user_data')
@@ -2283,13 +2333,14 @@
         node.start_commissioning(admin)
         post_commit_hooks.reset()  # Ignore these for now.
         self.assertThat(node_start, MockCalledOnceWith(
-            admin, user_data, NODE_STATUS.NEW))
+            admin, user_data, NODE_STATUS.NEW, allow_power_cycle=True))
 
     def test_start_commissioning_sets_min_hwe_kernel(self):
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         user_data = factory.make_string().encode('ascii')
         generate_user_data = self.patch(
             commissioning, 'generate_user_data')
@@ -2300,11 +2351,34 @@
         post_commit_hooks.reset()  # Ignore these for now.
         self.assertEqual('hwe-v', node.min_hwe_kernel)
 
+    def test_start_commissioning_starts_node_if_already_on(self):
+        node = factory.make_Node(
+            interface=True, status=NODE_STATUS.NEW, power_type='manual',
+            power_state=POWER_STATE.ON)
+        node_start = self.patch(node, '_start')
+        # Return a post-commit hook from Node.start().
+        node_start.side_effect = (
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
+        admin = factory.make_admin()
+        node.start_commissioning(admin)
+        post_commit_hooks.reset()  # Ignore these for now.
+        node = reload_object(node)
+        expected_attrs = {
+            'status': NODE_STATUS.COMMISSIONING,
+            'owner': admin,
+        }
+        self.assertAttributes(node, expected_attrs)
+        self.expectThat(node.owner, Equals(admin))
+        self.assertThat(node_start, MockCalledOnceWith(
+            admin, ANY, NODE_STATUS.NEW, allow_power_cycle=True))
+
     def test_start_commissioning_clears_node_commissioning_results(self):
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         NodeResult.objects.store_data(
             node, factory.make_string(),
             random.randint(0, 10),
@@ -2318,7 +2392,8 @@
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         clear_storage = self.patch_autospec(
             node, '_clear_full_storage_configuration')
         admin = factory.make_admin()
@@ -2330,7 +2405,8 @@
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         clear_storage = self.patch_autospec(
             node, '_clear_full_storage_configuration')
         admin = factory.make_admin()
@@ -2342,7 +2418,8 @@
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         clear_networking = self.patch_autospec(
             node, '_clear_networking_configuration')
         admin = factory.make_admin()
@@ -2354,7 +2431,8 @@
         node = factory.make_Node(status=NODE_STATUS.NEW)
         node_start = self.patch(node, '_start')
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         clear_networking = self.patch_autospec(
             node, '_clear_networking_configuration')
         admin = factory.make_admin()
@@ -2398,7 +2476,8 @@
         self.assertThat(
             node_start,
             MockCalledOnceWith(
-                admin, generate_user_data.return_value, NODE_STATUS.NEW))
+                admin, generate_user_data.return_value, NODE_STATUS.NEW,
+                allow_power_cycle=True))
         self.assertEqual(NODE_STATUS.NEW, node.status)
 
     def test_start_commissioning_logs_and_raises_errors_in_starting(self):
@@ -2422,7 +2501,8 @@
         node_start = self.patch(node, '_start')
         # Return a post-commit hook from Node.start().
         node_start.side_effect = (
-            lambda user, user_data, old_status: post_commit())
+            lambda user, user_data, old_status, allow_power_cycle: (
+                post_commit()))
         admin = factory.make_admin()
         node.start_commissioning(admin)
         post_commit_hooks.reset()  # Ignore these for now.
@@ -2640,11 +2720,10 @@
 
     def test_full_clean_checks_architecture_for_installable_nodes(self):
         device = factory.make_Device(architecture='')
-        # Set type here so we don't cause exception while creating object
-        node = typecast_node(device, Node)
-        node.node_type = factory.pick_enum(
+        device.node_type = factory.pick_enum(
             NODE_TYPE, but_not=[NODE_TYPE.DEVICE])
-        exception = self.assertRaises(ValidationError, node.full_clean)
+        exception = self.assertRaises(
+            ValidationError, device.as_node().full_clean)
         self.assertEqual(
             exception.message_dict,
             {'architecture':
@@ -2985,9 +3064,7 @@
             INTERFACE_TYPE.PHYSICAL, mac_address='ec:a8:6b:fd:ae:3f',
             node=node)
         node.save()
-        self.assertEqual(
-            "ELITEGROUP COMPUTER SYSTEMS CO., LTD.",
-            node.get_pxe_mac_vendor())
+        self.assertThat(node.get_pxe_mac_vendor(), IsNonEmptyString)
 
     def test_get_extra_macs_returns_all_but_boot_interface_mac(self):
         node = factory.make_Node()
@@ -4914,10 +4991,12 @@
         register_view("maasserver_discovery")
 
     def make_acquired_node_with_interface(
-            self, user, bmc_connected_to=None, power_type="virsh"):
+            self, user, bmc_connected_to=None, power_type="virsh",
+            power_state=POWER_STATE.OFF):
         node = factory.make_Node_with_Interface_on_Subnet(
             status=NODE_STATUS.READY, with_boot_disk=True,
-            bmc_connected_to=bmc_connected_to, power_type=power_type)
+            bmc_connected_to=bmc_connected_to, power_type=power_type,
+            power_state=power_state)
         node.acquire(user)
         return node
 
@@ -5035,6 +5114,24 @@
                      node.system_id, status=old_status),
                 call(callOutToDatabase, node.release_interface_config)))
 
+    def test__calls_power_cycle_when_cycling_allowed(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_interface(
+            user, power_state=POWER_STATE.ON)
+
+        post_commit_defer = self.patch(node_module, "post_commit")
+        mock_power_control = self.patch(Node, "_power_control_node")
+        mock_power_control.return_value = post_commit_defer
+
+        # Power cycling is allowed when starting deployment. This node is
+        # allocated and the power_state is ON. Power cycle should be called
+        # instead of power_on.
+        node.start(user)
+
+        # Calls _power_control_node when power_cycle.
+        self.assertThat(
+            mock_power_control, MockCalledOnceWith(ANY, power_cycle, ANY))
+
     def test_storage_layout_issues_returns_invalid_no_boot_arm64_non_efi(self):
         node = factory.make_Node(
             architecture="arm64/generic", bios_boot_method="pxe")
@@ -5640,8 +5737,7 @@
     )
 
     def create_empty_controller(self):
-        node = factory.make_Node(node_type=self.node_type)
-        return typecast_to_node_type(node)
+        return factory.make_Node(node_type=self.node_type).as_self()
 
     def test__order_of_calls_to_update_interface_is_always_the_same(self):
         controller = self.create_empty_controller()
@@ -8369,7 +8465,7 @@
         region_and_rack = factory.make_Node(
             node_type=NODE_TYPE.REGION_AND_RACK_CONTROLLER)
         system_id = region_and_rack.system_id
-        typecast_node(region_and_rack, RackController).delete()
+        region_and_rack.as_rack_controller().delete()
         self.assertEquals(
             NODE_TYPE.REGION_CONTROLLER,
             Node.objects.get(system_id=system_id).node_type)
@@ -8576,7 +8672,7 @@
     def test_delete_converts_region_and_rack_to_rack(self):
         region_and_rack = factory.make_Node(
             node_type=NODE_TYPE.REGION_AND_RACK_CONTROLLER)
-        typecast_node(region_and_rack, RegionController).delete()
+        region_and_rack.as_region_controller().delete()
         self.assertEquals(
             NODE_TYPE.RACK_CONTROLLER,
             Node.objects.get(system_id=region_and_rack.system_id).node_type)
@@ -8776,3 +8872,25 @@
         self.assertThat(monitoring_state, Contains('eth2'))
         self.assertThat(
             monitoring_state['eth1'], Equals(eth1.get_discovery_state()))
+
+
+class TestChassis(MAASServerTestCase):
+
+    def test__domain_is_always_empty(self):
+        hostname = factory.make_hostname()
+        domain = factory.make_name("domain")
+        chassis = factory.make_Chassis(
+            hostname="%s.%s" % (hostname, domain))
+        self.assertEquals(hostname, chassis.hostname)
+        self.assertIsNone(chassis.domain)
+
+
+class TestStorage(MAASServerTestCase):
+
+    def test__domain_is_always_empty(self):
+        hostname = factory.make_hostname()
+        domain = factory.make_name("domain")
+        storage = factory.make_Storage(
+            hostname="%s.%s" % (hostname, domain))
+        self.assertEquals(hostname, storage.hostname)
+        self.assertIsNone(storage.domain)
 
=== modified file 'src/maasserver/models/tests/test_staticipaddress.py'
--- src/maasserver/models/tests/test_staticipaddress.py	2016-12-07 15:03:00 +0000
+++ src/maasserver/models/tests/test_staticipaddress.py	2016-12-07 15:50:52 +0000
@@ -9,11 +9,12 @@
     randint,
     shuffle,
 )
+import threading
 from unittest import skip
 from unittest.mock import sentinel
 
 from django.core.exceptions import ValidationError
-from django.db import transaction
+from django.db import IntegrityError
 from maasserver import locks
 from maasserver.dbviews import register_view
 from maasserver.enum import (
@@ -41,29 +42,39 @@
     MAASServerTestCase,
     MAASTransactionServerTestCase,
 )
-from maasserver.utils.dns import get_ip_based_hostname
+<<<<<<< TREE
+from maasserver.utils.dns import get_ip_based_hostname
+=======
+from maasserver.utils import orm
+from maasserver.utils.dns import get_ip_based_hostname
+>>>>>>> MERGE-SOURCE
 from maasserver.utils.orm import (
     reload_object,
-    RetryTransaction,
     transactional,
 )
 from maasserver.websockets.base import dehydrate_datetime
-from maastesting.matchers import (
-    MockCalledOnceWith,
-    MockNotCalled,
-)
 from netaddr import IPAddress
+from psycopg2.errorcodes import FOREIGN_KEY_VIOLATION
 from testtools import ExpectedException
 from testtools.matchers import (
+    AfterPreprocessing,
+    AllMatch,
     Contains,
     Equals,
     HasLength,
+    Is,
+    IsInstance,
     Not,
 )
+from twisted.python.failure import Failure
 
 
 class TestStaticIPAddressManager(MAASServerTestCase):
 
+    def setUp(self):
+        super(TestStaticIPAddressManager, self).setUp()
+        register_view("maasserver_discovery")
+
     def test_filter_by_ip_family_ipv4(self):
         network_v4 = factory.make_ipv4_network()
         subnet_v4 = factory.make_Subnet(cidr=str(network_v4.cidr))
@@ -134,36 +145,21 @@
             StaticIPAddress.objects.filter_by_subnet_cidr_family(
                 IPADDRESS_FAMILY.IPv6))
 
-
-class TestStaticIPAddressManagerTransactional(MAASTransactionServerTestCase):
-    """The following TestStaticIPAddressManager tests require
-    MAASTransactionServerTestCase, and thus have been separated from the
-    TestStaticIPAddressManager above.
-    """
-
-    def setUp(self):
-        register_view("maasserver_discovery")
-        return super().setUp()
-
     def test_allocate_new_returns_ip_in_correct_range(self):
-        with transaction.atomic():
-            subnet = factory.make_managed_Subnet()
-        with transaction.atomic():
-            ipaddress = StaticIPAddress.objects.allocate_new(subnet)
+        subnet = factory.make_managed_Subnet()
+        ipaddress = StaticIPAddress.objects.allocate_new(subnet)
         self.assertIsInstance(ipaddress, StaticIPAddress)
         self.assertTrue(
             subnet.is_valid_static_ip(ipaddress.ip),
             "%s: not valid for subnet with reserved IPs: %r" % (
                 ipaddress.ip, subnet.get_ipranges_in_use()))
 
-    @transactional
     def test_allocate_new_allocates_IPv6_address(self):
-        subnet = factory.make_managed_ipv6_Subnet()
+        subnet = factory.make_managed_Subnet(ipv6=True)
         ipaddress = StaticIPAddress.objects.allocate_new(subnet)
         self.assertIsInstance(ipaddress, StaticIPAddress)
         self.assertTrue(subnet.is_valid_static_ip(ipaddress.ip))
 
-    @transactional
     def test_allocate_new_sets_user(self):
         subnet = factory.make_managed_Subnet()
         user = factory.make_User()
@@ -171,7 +167,6 @@
             subnet=subnet, alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=user)
         self.assertEqual(user, ipaddress.user)
 
-    @transactional
     def test_allocate_new_with_user_disallows_wrong_alloc_types(self):
         subnet = factory.make_managed_Subnet()
         user = factory.make_User()
@@ -185,7 +180,6 @@
             StaticIPAddress.objects.allocate_new(
                 subnet, user=user, alloc_type=alloc_type)
 
-    @transactional
     def test_allocate_new_with_reserved_type_requires_a_user(self):
         subnet = factory.make_managed_Subnet()
         with ExpectedException(AssertionError):
@@ -196,18 +190,15 @@
         # Django has a bug that casts IP addresses with HOST(), which
         # results in alphabetical comparisons of strings instead of IP
         # addresses.  See https://bugs.launchpad.net/maas/+bug/1338452
-        with transaction.atomic():
-            subnet = factory.make_Subnet(
-                cidr='10.0.0.0/24', gateway_ip='10.0.0.1')
-            factory.make_IPRange(subnet, '10.0.0.2', '10.0.0.97')
-            factory.make_IPRange(subnet, '10.0.0.101', '10.0.0.254')
-            factory.make_StaticIPAddress("10.0.0.99", subnet=subnet)
-            subnet = reload_object(subnet)
-        with transaction.atomic():
-            ipaddress = StaticIPAddress.objects.allocate_new(subnet)
-            self.assertEqual(ipaddress.ip, "10.0.0.98")
+        subnet = factory.make_Subnet(
+            cidr='10.0.0.0/24', gateway_ip='10.0.0.1')
+        factory.make_IPRange(subnet, '10.0.0.2', '10.0.0.97')
+        factory.make_IPRange(subnet, '10.0.0.101', '10.0.0.254')
+        factory.make_StaticIPAddress("10.0.0.99", subnet=subnet)
+        subnet = reload_object(subnet)
+        ipaddress = StaticIPAddress.objects.allocate_new(subnet)
+        self.assertEqual(ipaddress.ip, "10.0.0.98")
 
-    @transactional
     def test_allocate_new_returns_requested_IP_if_available(self):
         subnet = factory.make_Subnet(cidr='10.0.0.0/24')
         ipaddress = StaticIPAddress.objects.allocate_new(
@@ -220,7 +211,6 @@
             requested_address='10.0.0.1')
         self.assertEqual('10.0.0.1', ipaddress.ip)
 
-    @transactional
     def test_allocate_new_raises_when_requested_IP_unavailable(self):
         subnet = factory.make_ipv4_Subnet_with_IPRanges()
         requested_address = StaticIPAddress.objects.allocate_new(
@@ -235,28 +225,6 @@
             StaticIPAddress.objects.allocate_new(
                 subnet, requested_address=requested_address)
 
-    @transactional
-    def test_allocate_new_requests_transaction_retry_if_ip_taken(self):
-        subnet = factory.make_ipv4_Subnet_with_IPRanges()
-        # Simulate a "IP already taken" error.
-        mock_attempt_allocation = self.patch(
-            StaticIPAddress.objects, '_attempt_allocation')
-        mock_attempt_allocation.side_effect = StaticIPAddressUnavailable()
-        self.assertRaises(
-            RetryTransaction, StaticIPAddress.objects.allocate_new, subnet)
-
-    @transactional
-    def test_allocate_new_does_not_use_lock_for_requested_ip(self):
-        # When requesting a specific IP address, there's no need to
-        # acquire the lock.
-        lock = self.patch(locks, 'staticip_acquire')
-        subnet = factory.make_Subnet(cidr='10.0.0.0/24')
-        ipaddress = StaticIPAddress.objects.allocate_new(
-            subnet, requested_address='10.0.0.1')
-        self.assertIsInstance(ipaddress, StaticIPAddress)
-        self.assertThat(lock.__enter__, MockNotCalled())
-
-    @transactional
     def test_allocate_new_raises_when_requested_IP_out_of_network(self):
         subnet = factory.make_Subnet(cidr='10.0.0.0/24')
         requested_address = '10.0.1.1'
@@ -275,31 +243,28 @@
             str(e))
 
     def test_allocate_new_raises_when_requested_IP_in_dynamic_range(self):
-        with transaction.atomic():
-            subnet = factory.make_ipv4_Subnet_with_IPRanges()
-            dynamic_range = subnet.get_dynamic_ranges().first()
-            requested_address = str(IPAddress(
-                dynamic_range.netaddr_iprange.first))
-            dynamic_range_end = str(IPAddress(
-                dynamic_range.netaddr_iprange.last))
-            subnet = reload_object(subnet)
-        with transaction.atomic():
-            e = self.assertRaises(
-                StaticIPAddressUnavailable,
-                StaticIPAddress.objects.allocate_new,
-                subnet, factory.pick_enum(
-                    IPADDRESS_TYPE, but_not=[
-                        IPADDRESS_TYPE.DHCP,
-                        IPADDRESS_TYPE.DISCOVERED,
-                        IPADDRESS_TYPE.USER_RESERVED,
-                    ]),
-                requested_address=requested_address)
-            self.assertEqual(
-                "%s is within the dynamic range from %s to %s" % (
-                    requested_address, requested_address, dynamic_range_end),
-                str(e))
+        subnet = factory.make_ipv4_Subnet_with_IPRanges()
+        dynamic_range = subnet.get_dynamic_ranges().first()
+        requested_address = str(IPAddress(
+            dynamic_range.netaddr_iprange.first))
+        dynamic_range_end = str(IPAddress(
+            dynamic_range.netaddr_iprange.last))
+        subnet = reload_object(subnet)
+        e = self.assertRaises(
+            StaticIPAddressUnavailable,
+            StaticIPAddress.objects.allocate_new,
+            subnet, factory.pick_enum(
+                IPADDRESS_TYPE, but_not=[
+                    IPADDRESS_TYPE.DHCP,
+                    IPADDRESS_TYPE.DISCOVERED,
+                    IPADDRESS_TYPE.USER_RESERVED,
+                ]),
+            requested_address=requested_address)
+        self.assertEqual(
+            "%s is within the dynamic range from %s to %s" % (
+                requested_address, requested_address, dynamic_range_end),
+            str(e))
 
-    @transactional
     def test_allocate_new_raises_when_alloc_type_is_None(self):
         error = self.assertRaises(
             ValueError, StaticIPAddress.objects.allocate_new,
@@ -308,7 +273,6 @@
             "IP address type None is not allowed to use allocate_new.",
             str(error))
 
-    @transactional
     def test_allocate_new_raises_when_alloc_type_is_not_allowed(self):
         error = self.assertRaises(
             ValueError, StaticIPAddress.objects.allocate_new,
@@ -317,32 +281,98 @@
             "IP address type 5 is not allowed to use allocate_new.",
             str(error))
 
-    @transactional
-    def test_allocate_new_uses_staticip_acquire_lock(self):
-        lock = self.patch(locks, 'staticip_acquire')
-        subnet = factory.make_ipv4_Subnet_with_IPRanges()
-        ipaddress = StaticIPAddress.objects.allocate_new(subnet)
-        self.assertIsInstance(ipaddress, StaticIPAddress)
-        self.assertThat(lock.__enter__, MockCalledOnceWith())
-        self.assertThat(
-            lock.__exit__, MockCalledOnceWith(None, None, None))
-
     def test_allocate_new_raises_when_addresses_exhausted(self):
         network = "192.168.230.0/24"
-        with transaction.atomic():
-            subnet = factory.make_Subnet(cidr=network)
-            factory.make_IPRange(
-                subnet, '192.168.230.1', '192.168.230.254',
-                type=IPRANGE_TYPE.RESERVED)
-        with transaction.atomic():
-            e = self.assertRaises(
-                StaticIPAddressExhaustion,
-                StaticIPAddress.objects.allocate_new,
-                subnet)
+        subnet = factory.make_Subnet(cidr=network)
+        factory.make_IPRange(
+            subnet, '192.168.230.1', '192.168.230.254',
+            type=IPRANGE_TYPE.RESERVED)
+        e = self.assertRaises(
+            StaticIPAddressExhaustion,
+            StaticIPAddress.objects.allocate_new,
+            subnet)
         self.assertEqual(
             "No more IPs available in subnet: %s." % subnet.cidr,
             str(e))
 
+    def test_allocate_new_requests_retry_when_free_address_taken(self):
+        set_ip_address = self.patch(StaticIPAddress, "set_ip_address")
+        set_ip_address.side_effect = orm.make_unique_violation()
+        with orm.retry_context:
+            # A retry has been requested.
+            self.assertRaises(
+                orm.RetryTransaction, StaticIPAddress.objects.allocate_new,
+                subnet=factory.make_managed_Subnet())
+            # Aquisition of `address_allocation` is pending.
+            self.assertThat(
+                list(orm.retry_context.stack._cm_pending),
+                Equals([locks.address_allocation]))
+
+    def test_allocate_new_propagates_other_integrity_errors(self):
+        set_ip_address = self.patch(StaticIPAddress, "set_ip_address")
+        set_ip_address.side_effect = orm.make_unique_violation()
+        set_ip_address.side_effect.__cause__.pgcode = FOREIGN_KEY_VIOLATION
+        with orm.retry_context:
+            # An integrity error that's not `UNIQUE_VIOLATION` is propagated.
+            self.assertRaises(
+                IntegrityError, StaticIPAddress.objects.allocate_new,
+                subnet=factory.make_managed_Subnet())
+            # There is no pending retry context.
+            self.assertThat(
+                orm.retry_context.stack._cm_pending,
+                HasLength(0))
+
+
+class TestStaticIPAddressManagerTransactional(MAASTransactionServerTestCase):
+    """Transactional tests for `StaticIPAddressManager."""
+
+    scenarios = (
+        ("IPv4", dict(ip_version=4)),
+        ("IPv6", dict(ip_version=6)),
+    )
+
+    def test_allocate_new_works_under_extreme_concurrency(self):
+        register_view("maasserver_discovery")
+
+        ipv6 = (self.ip_version == 6)
+        subnet = factory.make_managed_Subnet(ipv6=ipv6)
+        count = 20  # Allocate this number of IP addresses.
+        concurrency = threading.Semaphore(16)
+        mutex = threading.Lock()
+        results = []
+
+        @transactional
+        def allocate():
+            return StaticIPAddress.objects.allocate_new(subnet)
+
+        def allocate_one():
+            try:
+                with concurrency:
+                    sip = allocate()
+            except:
+                failure = Failure()
+                with mutex:
+                    results.append(failure)
+            else:
+                with mutex:
+                    results.append(sip)
+
+        threads = [
+            threading.Thread(target=allocate_one)
+            for _ in range(count)
+        ]
+
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        self.assertThat(results, AllMatch(IsInstance(StaticIPAddress)))
+        ips = {sip.ip for sip in results}
+        self.assertThat(ips, HasLength(count))
+        self.assertThat(ips, AllMatch(
+            AfterPreprocessing(subnet.is_valid_static_ip, Is(True))))
+
 
 class TestStaticIPAddressManagerMapping(MAASServerTestCase):
     """Tests for get_hostname_ip_mapping()."""
 
=== modified file 'src/maasserver/models/tests/test_subnet.py'
--- src/maasserver/models/tests/test_subnet.py	2016-10-18 00:19:51 +0000
+++ src/maasserver/models/tests/test_subnet.py	2016-12-07 15:50:52 +0000
@@ -35,6 +35,7 @@
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import rollback
 from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.utils.orm import reload_object
 from maastesting.matchers import DocTestMatches
 from netaddr import (
     AddrFormatError,
@@ -615,7 +616,7 @@
                 parent, subnet.get_smallest_enclosing_sane_subnet())
 
     def test_cannot_delete_with_dhcp_enabled(self):
-        subnet = factory.make_managed_Subnet(ipv6=False)
+        subnet = factory.make_ipv4_Subnet_with_IPRanges()
         with ExpectedException(ValidationError, ".*servicing a dynamic.*"):
             subnet.delete()
 
@@ -898,13 +899,37 @@
 
 class TestSubnetGetNextIPForAllocation(MAASServerTestCase):
 
+    scenarios = (
+        ("managed", {'managed': True}),
+        ("unmanaged", {'managed': False}),
+    )
+
+    def make_Subnet(self, *args, **kwargs):
+        """Helper to create a subnet for this test suite.
+
+        Eclipses the entire subnet with an IPRange of type RESERVED, so that
+        unmanaged and managed test scenarios are expected to behave the same.
+        """
+        cidr = kwargs.get('cidr')
+        network = IPNetwork(cidr)
+        # Note: these tests assume IPv4.
+        first = str(IPAddress(network.first + 1))
+        last = str(IPAddress(network.last - 1))
+        subnet = factory.make_Subnet(*args, managed=self.managed, **kwargs)
+        if not self.managed:
+            factory.make_IPRange(
+                subnet, start_ip=first, end_ip=last,
+                type=IPRANGE_TYPE.RESERVED)
+            subnet = reload_object(subnet)
+        return subnet
+
     def setUp(self):
         register_view("maasserver_discovery")
         return super().setUp()
 
     def test__raises_if_no_free_addresses(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
-        subnet = factory.make_Subnet(
+        subnet = self.make_Subnet(
             cidr="10.0.0.0/30", gateway_ip="10.0.0.1",
             dns_servers=["10.0.0.2"])
         with ExpectedException(
@@ -914,35 +939,39 @@
 
     def test__allocates_next_free_address(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
-        subnet = factory.make_Subnet(
-            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None)
+        subnet = self.make_Subnet(
+            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None,
+            )
         ip = subnet.get_next_ip_for_allocation()
         self.assertThat(ip, Equals("10.0.0.1"))
 
     def test__avoids_gateway_ip(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
-        subnet = factory.make_Subnet(
-            cidr="10.0.0.0/30", gateway_ip="10.0.0.1", dns_servers=None)
+        subnet = self.make_Subnet(
+            cidr="10.0.0.0/30", gateway_ip="10.0.0.1", dns_servers=None,
+            )
         ip = subnet.get_next_ip_for_allocation()
         self.assertThat(ip, Equals("10.0.0.2"))
 
     def test__avoids_excluded_addresses(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
         subnet = factory.make_Subnet(
-            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None)
+            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None,
+            )
         ip = subnet.get_next_ip_for_allocation(exclude_addresses=["10.0.0.1"])
         self.assertThat(ip, Equals("10.0.0.2"))
 
     def test__avoids_dns_servers(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
         subnet = factory.make_Subnet(
-            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=["10.0.0.1"])
+            cidr="10.0.0.0/30", gateway_ip=None, dns_servers=["10.0.0.1"],
+            )
         ip = subnet.get_next_ip_for_allocation()
         self.assertThat(ip, Equals("10.0.0.2"))
 
     def test__avoids_observed_neighbours(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
-        subnet = factory.make_Subnet(
+        subnet = self.make_Subnet(
             cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None)
         rackif = factory.make_Interface(vlan=subnet.vlan)
         factory.make_Discovery(ip="10.0.0.1", interface=rackif)
@@ -951,7 +980,7 @@
 
     def test__logs_if_suggests_previously_observed_neighbour(self):
         # Note: 10.0.0.0/30 --> 10.0.0.1 and 10.0.0.0.2 are usable.
-        subnet = factory.make_Subnet(
+        subnet = self.make_Subnet(
             cidr="10.0.0.0/30", gateway_ip=None, dns_servers=None)
         rackif = factory.make_Interface(vlan=subnet.vlan)
         now = datetime.now()
@@ -969,7 +998,7 @@
 
     def test__uses_smallest_free_range_when_not_considering_neighbours(self):
         # Note: 10.0.0.0/29 --> 10.0.0.1 through 10.0.0.0.6 are usable.
-        subnet = factory.make_Subnet(
+        subnet = self.make_Subnet(
             cidr="10.0.0.0/29", gateway_ip=None, dns_servers=None)
         # With .4 in use, the free ranges are {1, 2, 3}, {5, 6}. So MAAS should
         # select 10.0.0.5, since that is the first address in the smallest
@@ -977,3 +1006,48 @@
         factory.make_StaticIPAddress(ip="10.0.0.4", cidr="10.0.0.0/29")
         ip = subnet.get_next_ip_for_allocation()
         self.assertThat(ip, Equals("10.0.0.5"))
+
+
+class TestUnmanagedSubnets(MAASServerTestCase):
+    def setUp(self):
+        register_view("maasserver_discovery")
+        return super().setUp()
+
+    def test__allocation_uses_reserved_range(self):
+        # Note: 10.0.0.0/29 --> 10.0.0.1 through 10.0.0.0.6 are usable.
+        subnet = factory.make_Subnet(
+            cidr="10.0.0.0/29", gateway_ip=None, dns_servers=None,
+            managed=False)
+        range1 = factory.make_IPRange(
+            subnet, start_ip='10.0.0.1', end_ip='10.0.0.1',
+            type=IPRANGE_TYPE.RESERVED)
+        subnet = reload_object(subnet)
+        ip = subnet.get_next_ip_for_allocation()
+        self.assertThat(ip, Equals("10.0.0.1"))
+        range1.delete()
+        factory.make_IPRange(
+            subnet, start_ip='10.0.0.6', end_ip='10.0.0.6',
+            type=IPRANGE_TYPE.RESERVED)
+        subnet = reload_object(subnet)
+        ip = subnet.get_next_ip_for_allocation()
+        self.assertThat(ip, Equals("10.0.0.6"))
+
+    def test__allocation_uses_multiple_reserved_ranges(self):
+        # Note: 10.0.0.0/29 --> 10.0.0.1 through 10.0.0.0.6 are usable.
+        subnet = factory.make_Subnet(
+            cidr="10.0.0.0/29", gateway_ip=None, dns_servers=None,
+            managed=False)
+        factory.make_IPRange(
+            subnet, start_ip='10.0.0.3', end_ip='10.0.0.4',
+            type=IPRANGE_TYPE.RESERVED)
+        subnet = reload_object(subnet)
+        ip = subnet.get_next_ip_for_allocation()
+        self.assertThat(ip, Equals("10.0.0.3"))
+        factory.make_StaticIPAddress(ip)
+        ip = subnet.get_next_ip_for_allocation()
+        self.assertThat(ip, Equals("10.0.0.4"))
+        factory.make_StaticIPAddress(ip)
+        with ExpectedException(
+                StaticIPAddressExhaustion,
+                "No more IPs available in subnet: 10.0.0.0/29."):
+            subnet.get_next_ip_for_allocation()
 
=== modified file 'src/maasserver/models/tests/test_vlan.py'
--- src/maasserver/models/tests/test_vlan.py	2016-10-19 18:06:01 +0000
+++ src/maasserver/models/tests/test_vlan.py	2016-12-07 15:50:52 +0000
@@ -88,6 +88,14 @@
 
 class TestVLAN(MAASServerTestCase):
 
+    def test_delete_relay_vlan_doesnt_delete_vlan(self):
+        relay_vlan = factory.make_VLAN()
+        vlan = factory.make_VLAN(relay_vlan=relay_vlan)
+        relay_vlan.delete()
+        vlan = reload_object(vlan)
+        self.assertIsNotNone(vlan)
+        self.assertIsNone(vlan.relay_vlan)
+
     def test_get_name_for_default_vlan_is_untagged(self):
         fabric = factory.make_Fabric()
         self.assertEqual("untagged", fabric.get_default_vlan().get_name())
 
=== modified file 'src/maasserver/models/vlan.py'
--- src/maasserver/models/vlan.py	2016-10-20 19:39:48 +0000
+++ src/maasserver/models/vlan.py	2016-12-07 15:50:52 +0000
@@ -14,6 +14,7 @@
 from django.db.models import (
     BooleanField,
     CharField,
+    deletion,
     ForeignKey,
     IntegerField,
     Manager,
@@ -169,6 +170,10 @@
         'RackController', null=True, blank=True, editable=True,
         related_name='+')
 
+    relay_vlan = ForeignKey(
+        'self', null=True, blank=True, editable=True,
+        related_name='relay_vlans', on_delete=deletion.SET_NULL)
+
     def __str__(self):
         return "%s.%s" % (self.fabric.get_name(), self.get_name())
 
 
=== modified file 'src/maasserver/node_action.py'
--- src/maasserver/node_action.py	2016-08-16 09:31:16 +0000
+++ src/maasserver/node_action.py	2016-12-07 15:50:52 +0000
@@ -230,10 +230,6 @@
             self, enable_ssh=False, skip_networking=False,
             skip_storage=False):
         """See `NodeAction.execute`."""
-        if self.node.power_state == POWER_STATE.ON:
-            raise NodeActionError(
-                "Unable to be commissioned because the power is currently on.")
-
         try:
             self.node.start_commissioning(
                 self.user,
 
=== modified file 'src/maasserver/rpc/nodes.py'
--- src/maasserver/rpc/nodes.py	2016-10-20 08:41:30 +0000
+++ src/maasserver/rpc/nodes.py	2016-12-07 15:50:52 +0000
@@ -30,6 +30,7 @@
 )
 from maasserver.models.timestampedmodel import now
 from maasserver.utils.orm import transactional
+from provisioningserver.drivers.power import PowerDriverRegistry
 from provisioningserver.rpc.exceptions import (
     CommissionNodeFailed,
     NodeAlreadyExists,
@@ -66,16 +67,16 @@
     :return: A generator yielding `dict`s.
     """
     five_minutes_ago = now() - timedelta(minutes=5)
-
-    # This is meant to be temporary until all the power types support querying
-    # the power state of a node. See the definition of QUERY_POWER_TYPES for
-    # more information.
-    from provisioningserver.power import QUERY_POWER_TYPES
+    queryable_power_types = [
+        driver.name
+        for _, driver in PowerDriverRegistry
+        if driver.queryable
+    ]
 
     nodes_unchecked = (
         nodes
         .filter(power_state_queried=None)
-        .filter(bmc__power_type__in=QUERY_POWER_TYPES)
+        .filter(bmc__power_type__in=queryable_power_types)
         .exclude(status=NODE_STATUS.BROKEN)
         .distinct()
     )
@@ -83,7 +84,7 @@
         nodes
         .exclude(power_state_queried=None)
         .exclude(power_state_queried__gt=five_minutes_ago)
-        .filter(bmc__power_type__in=QUERY_POWER_TYPES)
+        .filter(bmc__power_type__in=queryable_power_types)
         .exclude(status=NODE_STATUS.BROKEN)
         .order_by("power_state_queried", "system_id")
         .distinct()
 
=== modified file 'src/maasserver/rpc/rackcontrollers.py'
--- src/maasserver/rpc/rackcontrollers.py	2016-10-17 06:42:10 +0000
+++ src/maasserver/rpc/rackcontrollers.py	2016-12-07 15:50:52 +0000
@@ -26,7 +26,6 @@
     RegionController,
     StaticIPAddress,
 )
-from maasserver.models.node import typecast_node
 from maasserver.models.timestampedmodel import now
 from maasserver.utils import synchronised
 from maasserver.utils.orm import (
@@ -120,7 +119,7 @@
         node.node_type = NODE_TYPE.RACK_CONTROLLER
         node.save()
 
-    rackcontroller = typecast_node(node, RackController)
+    rackcontroller = node.as_rack_controller()
 
     # Update `rackcontroller.url` from the given URL, if it has changed.
     update_fields = []
 
=== modified file 'src/maasserver/rpc/regionservice.py'
--- src/maasserver/rpc/regionservice.py	2016-10-28 15:58:32 +0000
+++ src/maasserver/rpc/regionservice.py	2016-12-07 15:50:52 +0000
@@ -642,19 +642,17 @@
             # and into the database.
             self.ident = rack_controller.system_id
             self.factory.service._addConnectionFor(self.ident, self)
+
+            # A local rack is treated differently to one that's remote.
             self.host = self.transport.getHost()
             self.hostIsRemote = isinstance(
                 self.host, (IPv4Address, IPv6Address))
 
-            # Get the region ID if we're dealing with a non-local rack; we
-            # won't need to bother for local racks.
+            # Only register the connection into the database when it's a valid