Merge lp:~blake-rouse/maas/fix-pod-delete into lp:~maas-committers/maas/trunk

[Blake Rouse]

Fix pod deletion to only decompose machines that MAAS has composed. Convert pod deletion into an async operation.

MAAS know records the creation type of a machine. This type allows MAAS to know what to do upon deletion of that machine. If the machine existed in the pod or was added to the pod out of band from MAAS then it will not be decomposed when the machine or pod is deleted. If the machine was created by MAAS then it will be decomposed in the pod when the machine or pod is deleted. The pod delete operation is not an asynchronous operation where it tries its best to decompose all machines. If decomposing fails then the deletion process will be stopped and the reason for the failure will be raised. If all the machines that required decomposition are successfully decomposed then it will also delete the pre-existing machines and the pod.

[Newell Jensen (newell-jensen)]

I am getting this error when doing a `make run` with your branch (I initially saw this when trying to install packages for RSD testing).

django.db.utils.ProgrammingError: column maasserver_node.creation_type does not exist
LINE 1: ...node"."netboot", "maasserver_node"."license_key", "maasserve...
                                                             ^

review: Needs Fixing

[Newell Jensen (newell-jensen)]

I tested this in the RSD lab. Deleting the Pod work with or without pre-composed nodes present.

review: Approve

=== modified file 'src/maasserver/api/pods.py'
--- src/maasserver/api/pods.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/api/pods.py	2017-02-18 00:02:02 +0000
@@ -13,12 +13,14 @@
     operation,
     OperationsHandler,
 )
+from maasserver.enum import NODE_CREATION_TYPE
 from maasserver.exceptions import MAASAPIValidationError
 from maasserver.forms.pods import (
     ComposeMachineForm,
     PodForm,
 )
 from maasserver.models.bmc import Pod
+from maasserver.models.node import Machine
 from piston3.utils import rc
 from provisioningserver.drivers.pod import Capabilities
 
@@ -108,7 +110,13 @@
         Returns 204 if the pod is successfully deleted.
         """
         pod = get_object_or_404(Pod, id=id)
-        pod.delete()
+        # Calculate the wait time based on the number of none pre-existing
+        # machines. We allow maximum of 60 seconds per machine plus 60 seconds
+        # for the pod.
+        num_machines = Machine.objects.filter(bmc=pod)
+        num_machines = num_machines.exclude(
+            creation_type=NODE_CREATION_TYPE.PRE_EXISTING)
+        pod.async_delete().wait((num_machines.count() * 60) + 60)
         return rc.DELETED
 
     @admin_method

=== modified file 'src/maasserver/api/tests/test_pods.py'
--- src/maasserver/api/tests/test_pods.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/api/tests/test_pods.py	2017-02-18 00:02:02 +0000
@@ -10,12 +10,15 @@
 from unittest.mock import MagicMock
 
 from django.core.urlresolvers import reverse
+from maasserver.enum import NODE_CREATION_TYPE
 from maasserver.forms import pods
+from maasserver.models.bmc import Pod
 from maasserver.models.node import Machine
 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
+from maastesting.matchers import MockCalledOnceWith
 from provisioningserver.drivers.pod import (
     Capabilities,
     DiscoveredMachine,
@@ -335,13 +338,25 @@
         self.assertEqual(
             http.client.BAD_REQUEST, response.status_code, response.content)
 
-    def test_DELETE_removes_pod(self):
+    def test_DELETE_calls_async_delete(self):
         self.become_admin()
         pod = factory.make_Pod()
+        for _ in range(3):
+            factory.make_Machine(
+                bmc=pod, creation_type=NODE_CREATION_TYPE.PRE_EXISTING)
+        for _ in range(3):
+            factory.make_Machine(
+                bmc=pod, creation_type=NODE_CREATION_TYPE.MANUAL)
+        for _ in range(3):
+            factory.make_Machine(
+                bmc=pod, creation_type=NODE_CREATION_TYPE.DYNAMIC)
+        mock_eventual = MagicMock()
+        mock_async_delete = self.patch(Pod, "async_delete")
+        mock_async_delete.return_value = mock_eventual
         response = self.client.delete(get_pod_uri(pod))
         self.assertEqual(
             http.client.NO_CONTENT, response.status_code, response.content)
-        self.assertIsNone(reload_object(pod))
+        self.assertThat(mock_eventual.wait, MockCalledOnceWith(60 * 7))
 
     def test_DELETE_rejects_deletion_if_not_permitted(self):
         pod = factory.make_Pod()

=== modified file 'src/maasserver/enum.py'
--- src/maasserver/enum.py	2017-01-28 00:51:47 +0000
+++ src/maasserver/enum.py	2017-02-18 00:02:02 +0000
@@ -188,6 +188,17 @@
 )
 
 
+class NODE_CREATION_TYPE:
+    """Creation types a machine can have in a node."""
+    #: Pre-existing, machine already exists in Pod when MAAS discovered it.
+    PRE_EXISTING = 1
+    #: Manual, machine was manually composed through MAAS.
+    MANUAL = 2
+    #: Dynamic, machine was composed during allocation and should be decomposed
+    # upon release of the machine.
+    DYNAMIC = 3
+
+
 class NODE_PERMISSION:
     """Permissions relating to nodes."""
     VIEW = 'view_node'

=== modified file 'src/maasserver/forms/pods.py'
--- src/maasserver/forms/pods.py	2017-02-10 17:51:00 +0000
+++ src/maasserver/forms/pods.py	2017-02-18 00:02:02 +0000
@@ -23,7 +23,10 @@
     discover_pod,
     get_best_discovered_result,
 )
-from maasserver.enum import BMC_TYPE
+from maasserver.enum import (
+    BMC_TYPE,
+    NODE_CREATION_TYPE,
+)
 from maasserver.exceptions import PodProblem
 from maasserver.forms import MAASModelForm
 from maasserver.models import (
@@ -278,6 +281,7 @@
 
         created_machine = self.pod.create_machine(
             discovered_machine, self.request.user,
-            skip_commissioning=skip_commissioning)
+            skip_commissioning=skip_commissioning,
+            creation_type=NODE_CREATION_TYPE.MANUAL)
         self.pod.sync_hints(pod_hints)
         return created_machine

=== added file 'src/maasserver/migrations/builtin/maasserver/0114_node_dynamic_to_creation_type.py'
--- src/maasserver/migrations/builtin/maasserver/0114_node_dynamic_to_creation_type.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0114_node_dynamic_to_creation_type.py	2017-02-18 00:02:02 +0000
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0113_set_filepath_limit_to_linux_max'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='node',
+            name='dynamic',
+        ),
+        migrations.AddField(
+            model_name='node',
+            name='creation_type',
+            field=models.IntegerField(default=1),
+        ),
+    ]

=== modified file 'src/maasserver/models/bmc.py'
--- src/maasserver/models/bmc.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/bmc.py	2017-02-18 00:02:02 +0000
@@ -7,6 +7,7 @@
     "BMC",
     ]
 
+from functools import partial
 import re
 
 from django.contrib.postgres.fields import ArrayField
@@ -25,13 +26,16 @@
 )
 from django.db.models.query import QuerySet
 from maasserver import DefaultMeta
+from maasserver.clusterrpc.pods import decompose_machine
 from maasserver.enum import (
     BMC_TYPE,
     BMC_TYPE_CHOICES,
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
+    NODE_CREATION_TYPE,
     NODE_STATUS,
 )
+from maasserver.exceptions import PodProblem
 from maasserver.fields import JSONObjectField
 from maasserver.models.blockdevice import BlockDevice
 from maasserver.models.cleansave import CleanSave
@@ -44,11 +48,18 @@
 from maasserver.models.subnet import Subnet
 from maasserver.models.tag import Tag
 from maasserver.models.timestampedmodel import TimestampedModel
-from maasserver.rpc import getAllClients
+from maasserver.rpc import (
+    getAllClients,
+    getClientFromIdentifiers,
+)
+from maasserver.utils.orm import transactional
+from maasserver.utils.threads import deferToDatabase
 import petname
 from provisioningserver.drivers import SETTING_SCOPE
 from provisioningserver.drivers.power.registry import PowerDriverRegistry
 from provisioningserver.logger import get_maas_logger
+from provisioningserver.utils.twisted import asynchronous
+from twisted.internet.defer import inlineCallbacks
 
 
 maaslog = get_maas_logger("node")
@@ -490,7 +501,8 @@
 
     def create_machine(
             self, discovered_machine, commissioning_user,
-            skip_commissioning=False):
+            skip_commissioning=False,
+            creation_type=NODE_CREATION_TYPE.PRE_EXISTING):
         """Create's a `Machine` from `discovered_machines` for this pod."""
         # Create the machine.
         machine = Machine(
@@ -499,7 +511,8 @@
             cpu_count=discovered_machine.cores,
             cpu_speed=discovered_machine.cpu_speed,
             memory=discovered_machine.memory,
-            power_state=discovered_machine.power_state)
+            power_state=discovered_machine.power_state,
+            creation_type=creation_type)
         machine.bmc = self
         machine.instance_power_parameters = discovered_machine.power_parameters
         machine.set_random_hostname()
@@ -796,6 +809,105 @@
             if isinstance(blockdevice.actual_instance, PhysicalBlockDevice)
         ])
 
+    def delete(self, *args, **kwargs):
+        raise AttributeError(
+            "Use `async_delete` instead. Deleting a Pod takes "
+            "an asynchronous action.")
+
+    @asynchronous
+    def async_delete(self):
+        """Delete a pod asynchronously.
+
+        Any machine in the pod that needs to be decomposed will be decomposed
+        before it is removed from the database. If a failure occurs during the
+        decomposition process then only the machines that where successfully
+        decomposed will be deleted in the database and the pod will not
+        be deleted. If all machines are successfully decomposed then the
+        machines that should not be decomposed and the pod will finally be
+        removed from the database.
+        """
+
+        @transactional
+        def gather_clients_and_machines(pod):
+            decompose, pre_existing = [], []
+            for machine in Machine.objects.filter(
+                    bmc__id=pod.id).order_by('id').select_related('bmc'):
+                if machine.creation_type == NODE_CREATION_TYPE.PRE_EXISTING:
+                    pre_existing.append(machine.id)
+                else:
+                    decompose.append((
+                        machine.id,
+                        machine.power_parameters))
+            return (
+                pod.id, pod.name, pod.power_type, pod.get_client_identifiers(),
+                decompose, pre_existing)
+
+        @inlineCallbacks
+        def decompose(result):
+            (pod_id, pod_name, pod_type, client_idents,
+             decompose, pre_existing) = result
+            decomposed, updated_hints, error = [], None, None
+            for machine_id, parameters in decompose:
+                # Get a new client for every decompose because we might lose
+                # a connection to a rack during this operation.
+                client = yield getClientFromIdentifiers(client_idents)
+                try:
+                    updated_hints = yield decompose_machine(
+                        client, pod_type, parameters,
+                        pod_id=pod_id, name=pod_name)
+                except PodProblem as exc:
+                    error = exc
+                    break
+                else:
+                    decomposed.append(machine_id)
+            return pod_id, decomposed, pre_existing, error, updated_hints
+
+        @transactional
+        def perform_deletion(result):
+            (pod_id, decomposed_ids, pre_existing_ids,
+             error, updated_hints) = result
+            # No matter the error for decompose, we ensure that the machines
+            # that where decomposed before the error are actually deleted.
+            pod = Pod.objects.get(id=pod_id)
+            machines = Machine.objects.filter(id__in=decomposed_ids)
+            for machine in machines:
+                # Clear BMC (aka. this pod) so the signal handler does not
+                # try to decompose of it. Its already been decomposed.
+                machine.bmc = None
+                machine.delete()
+
+            if error is not None:
+                # Error occurred so we update the pod hints as the pod and
+                # pre-existing machines will not be deleted. The error is
+                # returned not raised so that the transaction is not rolled
+                # back.
+                if updated_hints is not None:
+                    pod.sync_hints(updated_hints)
+                return error
+            else:
+                # Error did not occur. Delete the pre-existing machines
+                # and finally the pod.
+                for machine in Machine.objects.filter(id__in=pre_existing_ids):
+                    # We loop and call delete to ensure the `delete` method
+                    # on the machine object is actually called.
+                    machine.delete()
+                # Call delete by bypassing the override that prevents its call.
+                super(BMC, pod).delete()
+
+        def raise_error(error):
+            # Error gets returned from the previous callback if it should
+            # be raised. This way allows the transaction that was running
+            # in the other callback to be committed.
+            if error is not None:
+                raise error
+
+        # Don't catch any errors here they are raised to the caller.
+        d = deferToDatabase(gather_clients_and_machines, self)
+        d.addCallback(decompose)
+        d.addCallback(partial(deferToDatabase, perform_deletion))
+        d.addCallback(raise_error)
+        return d
+
 
 class BMCRoutableRackControllerRelationship(CleanSave, TimestampedModel):
     """Records the link routable status of a BMC from a RackController.

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/node.py	2017-02-18 00:02:02 +0000
@@ -72,6 +72,7 @@
     INTERFACE_TYPE,
     IPADDRESS_FAMILY,
     IPADDRESS_TYPE,
+    NODE_CREATION_TYPE,
     NODE_PERMISSION,
     NODE_STATUS,
     NODE_STATUS_CHOICES,
@@ -938,10 +939,10 @@
 
     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 pod during allocation. When the machine is
-    # released it will be deleted.
-    dynamic = BooleanField(default=False)
+    # Only used by Machine. Set to the creation type based on how the machine
+    # ended up in the Pod.
+    creation_type = IntegerField(
+        null=False, blank=False, default=NODE_CREATION_TYPE.PRE_EXISTING)
 
     tags = ManyToManyField(Tag)
 
@@ -2704,7 +2705,7 @@
         final power-down. This method should be the absolute last method
         called.
         """
-        if self.dynamic:
+        if self.creation_type == NODE_CREATION_TYPE.DYNAMIC:
             self.delete()
         else:
             self.release_interface_config()

=== modified file 'src/maasserver/models/signals/nodes.py'
--- src/maasserver/models/signals/nodes.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/signals/nodes.py	2017-02-18 00:02:02 +0000
@@ -17,6 +17,7 @@
 from maasserver.clusterrpc.pods import decompose_machine
 from maasserver.enum import (
     BMC_TYPE,
+    NODE_CREATION_TYPE,
     NODE_STATUS,
     NODE_TYPE,
 )
@@ -126,7 +127,8 @@
     if (instance.node_type == NODE_TYPE.MACHINE and
             bmc is not None and
             bmc.bmc_type == BMC_TYPE.POD and
-            Capabilities.COMPOSABLE in bmc.capabilities):
+            Capabilities.COMPOSABLE in bmc.capabilities and
+            instance.creation_type != NODE_CREATION_TYPE.PRE_EXISTING):
         pod = bmc.as_pod()
 
         @asynchronous

=== modified file 'src/maasserver/models/signals/tests/test_nodes.py'
--- src/maasserver/models/signals/tests/test_nodes.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/signals/tests/test_nodes.py	2017-02-18 00:02:02 +0000
@@ -10,6 +10,7 @@
 
 import crochet
 from maasserver.enum import (
+    NODE_CREATION_TYPE,
     NODE_STATUS,
     NODE_TYPE,
     NODE_TYPE_CHOICES,
@@ -214,6 +215,14 @@
         machine.delete()
         self.assertThat(client, MockNotCalled())
 
+    def test_does_nothing_if_pre_existing_machine(self):
+        client = self.fake_rpc_client()
+        machine = factory.make_Node()
+        machine.bmc = self.make_composable_pod()
+        machine.save()
+        machine.delete()
+        self.assertThat(client, MockNotCalled())
+
     def test_performs_decompose_machine(self):
         hints = DiscoveredPodHints(
             cores=random.randint(1, 8),
@@ -224,7 +233,8 @@
         client.return_value = succeed({
             'hints': hints,
         })
-        machine = factory.make_Node()
+        machine = factory.make_Node(
+            creation_type=NODE_CREATION_TYPE.MANUAL)
         machine.bmc = pod
         machine.instance_power_parameters = {
             'power_id': factory.make_name('power_id'),
@@ -246,7 +256,8 @@
         pod = self.make_composable_pod()
         client = self.fake_rpc_client()
         client.side_effect = crochet.TimeoutError()
-        machine = factory.make_Node()
+        machine = factory.make_Node(
+            creation_type=NODE_CREATION_TYPE.MANUAL)
         machine.bmc = pod
         machine.instance_power_parameters = {
             'power_id': factory.make_name('power_id'),
@@ -261,7 +272,8 @@
         pod = self.make_composable_pod()
         client = self.fake_rpc_client()
         client.return_value = fail(PodActionFail())
-        machine = factory.make_Node()
+        machine = factory.make_Node(
+            creation_type=NODE_CREATION_TYPE.MANUAL)
         machine.bmc = pod
         machine.instance_power_parameters = {
             'power_id': factory.make_name('power_id'),

=== modified file 'src/maasserver/models/tests/test_bmc.py'
--- src/maasserver/models/tests/test_bmc.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/tests/test_bmc.py	2017-02-18 00:02:02 +0000
@@ -6,18 +6,25 @@
 __all__ = []
 
 import random
-from unittest.mock import Mock
+from unittest.mock import (
+    Mock,
+    sentinel,
+)
 
+from crochet import wait_for
 from maasserver.enum import (
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
+    NODE_CREATION_TYPE,
     POWER_STATE,
 )
+from maasserver.exceptions import PodProblem
 from maasserver.models import bmc as bmc_module
 from maasserver.models.blockdevice import BlockDevice
 from maasserver.models.bmc import (
     BMC,
     BMCRoutableRackControllerRelationship,
+    Pod,
 )
 from maasserver.models.fabric import Fabric
 from maasserver.models.node import Machine
@@ -25,8 +32,12 @@
 from maasserver.models.staticipaddress import StaticIPAddress
 from maasserver.testing.factory import factory
 from maasserver.testing.matchers import MatchesSetwiseWithAll
-from maasserver.testing.testcase import MAASServerTestCase
+from maasserver.testing.testcase import (
+    MAASServerTestCase,
+    MAASTransactionServerTestCase,
+)
 from maasserver.utils.orm import reload_object
+from maasserver.utils.threads import deferToDatabase
 from maastesting.matchers import MockCalledOnceWith
 from provisioningserver.drivers.pod import (
     DiscoveredMachine,
@@ -35,12 +46,21 @@
     DiscoveredPod,
     DiscoveredPodHints,
 )
+from provisioningserver.rpc.cluster import DecomposeMachine
 from testtools.matchers import (
     Equals,
     HasLength,
     MatchesSetwise,
     MatchesStructure,
 )
+from twisted.internet.defer import (
+    fail,
+    inlineCallbacks,
+    succeed,
+)
+
+
+wait_for_reactor = wait_for(30)  # 30 seconds.
 
 
 class TestBMC(MAASServerTestCase):
@@ -665,6 +685,7 @@
                     memory=Equals(machine.memory),
                     power_state=Equals(machine.power_state),
                     instance_power_parameters=Equals(machine.power_parameters),
+                    creation_type=Equals(NODE_CREATION_TYPE.PRE_EXISTING),
                     tags=MatchesSetwiseWithAll(*[
                         MatchesStructure(name=Equals(tag))
                         for tag in machine.tags
@@ -919,3 +940,89 @@
                     Equals(tag)
                     for tag in dnew_interface.tags
                 ])))
+
+
+class TestPodDelete(MAASTransactionServerTestCase):
+
+    def test_delete_is_not_allowed(self):
+        pod = factory.make_Pod()
+        self.assertRaises(AttributeError, pod.delete)
+
+    @wait_for_reactor
+    @inlineCallbacks
+    def test_delete_async_simply_deletes_empty_pod(self):
+        pod = yield deferToDatabase(factory.make_Pod)
+        yield pod.async_delete()
+        pod = yield deferToDatabase(reload_object, pod)
+        self.assertIsNone(pod)
+
+    @wait_for_reactor
+    @inlineCallbacks
+    def test_decomposes_and_deletes_machines_and_pod(self):
+        pod = yield deferToDatabase(factory.make_Pod)
+        decomposable_machine = yield deferToDatabase(
+            factory.make_Machine, bmc=pod,
+            creation_type=NODE_CREATION_TYPE.MANUAL)
+        delete_machine = yield deferToDatabase(
+            factory.make_Machine, bmc=pod)
+        client = Mock()
+        client.return_value = succeed({'hints': None})
+        self.patch(
+            bmc_module, "getClientFromIdentifiers").return_value = client
+        yield pod.async_delete()
+        self.assertThat(
+            client, MockCalledOnceWith(
+                DecomposeMachine, type=pod.power_type, context={},
+                pod_id=pod.id, name=pod.name))
+        decomposable_machine = yield deferToDatabase(
+            reload_object, decomposable_machine)
+        delete_machine = yield deferToDatabase(reload_object, delete_machine)
+        pod = yield deferToDatabase(reload_object, pod)
+        self.assertIsNone(decomposable_machine)
+        self.assertIsNone(delete_machine)
+        self.assertIsNone(pod)
+
+    @wait_for_reactor
+    @inlineCallbacks
+    def test_decomposes_handles_failure_after_one_successful(self):
+        pod = yield deferToDatabase(factory.make_Pod)
+        decomposable_machine_one = yield deferToDatabase(
+            factory.make_Machine, bmc=pod,
+            creation_type=NODE_CREATION_TYPE.MANUAL)
+        decomposable_machine_two = yield deferToDatabase(
+            factory.make_Machine, bmc=pod,
+            creation_type=NODE_CREATION_TYPE.MANUAL)
+        delete_machine = yield deferToDatabase(
+            factory.make_Machine, bmc=pod)
+        client = Mock()
+        client.side_effect = [
+            succeed({'hints': sentinel.hints}),
+            fail(PodProblem()),
+        ]
+        mock_sync_hints = self.patch(Pod, 'sync_hints')
+        self.patch(
+            bmc_module, "getClientFromIdentifiers").return_value = client
+
+        # Ensure that the exeception is raised.
+        try:
+            yield pod.async_delete()
+        except PodProblem as exc:
+            pass
+        else:
+            self.fail("PodProblem exception was not raised.")
+
+        # Ensure that the pod hints where updated.
+        self.assertThat(mock_sync_hints, MockCalledOnceWith(sentinel.hints))
+
+        # Only the first machine should have been deleted, the others should
+        # all remain.
+        decomposable_machine_one = yield deferToDatabase(
+            reload_object, decomposable_machine_one)
+        decomposable_machine_two = yield deferToDatabase(
+            reload_object, decomposable_machine_two)
+        delete_machine = yield deferToDatabase(reload_object, delete_machine)
+        pod = yield deferToDatabase(reload_object, pod)
+        self.assertIsNone(decomposable_machine_one)
+        self.assertIsNotNone(decomposable_machine_two)
+        self.assertIsNotNone(delete_machine)
+        self.assertIsNotNone(pod)

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/models/tests/test_node.py	2017-02-18 00:02:02 +0000
@@ -43,6 +43,7 @@
     INTERFACE_LINK_TYPE,
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
+    NODE_CREATION_TYPE,
     NODE_PERMISSION,
     NODE_STATUS,
     NODE_STATUS_CHOICES,
@@ -1995,7 +1996,8 @@
         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)
+            creation_type=NODE_CREATION_TYPE.DYNAMIC,
+            power_state=POWER_STATE.OFF)
         with post_commit_hooks:
             node.release()
         self.assertIsNone(reload_object(node))

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/testing/factory.py	2017-02-18 00:02:02 +0000
@@ -372,7 +372,7 @@
             created=None, zone=None, networks=None, sortable_name=False,
             power_type=None, power_parameters=None, power_state=None,
             power_state_updated=undefined, with_boot_disk=True, vlan=None,
-            fabric=None, bmc_connected_to=None, owner_data={}, dynamic=False,
+            fabric=None, bmc_connected_to=None, owner_data={},
             with_empty_script_sets=False, **kwargs):
         """Make a :class:`Node`.
 
@@ -408,7 +408,7 @@
             min_hwe_kernel=min_hwe_kernel, hwe_kernel=hwe_kernel,
             node_type=node_type, zone=zone,
             power_state=power_state, power_state_updated=power_state_updated,
-            domain=domain, dynamic=dynamic, **kwargs)
+            domain=domain, **kwargs)
         node.power_type = power_type
         node.power_parameters = power_parameters
         self._save_node_unchecked(node)

=== modified file 'src/maasserver/websockets/handlers/device.py'
--- src/maasserver/websockets/handlers/device.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/websockets/handlers/device.py	2017-02-18 00:02:02 +0000
@@ -79,7 +79,7 @@
             'create_interface',
             'action']
         exclude = [
-            "dynamic",
+            "creation_type",
             "type",
             "boot_interface",
             "boot_cluster_ip",

=== modified file 'src/maasserver/websockets/handlers/machine.py'
--- src/maasserver/websockets/handlers/machine.py	2017-02-17 14:23:04 +0000
+++ src/maasserver/websockets/handlers/machine.py	2017-02-18 00:02:02 +0000
@@ -128,7 +128,7 @@
         ]
         form = AdminMachineWithMACAddressesForm
         exclude = [
-            "dynamic",
+            "creation_type",
             "status_expires",
             "previous_status",
             "parent",