Merge lp:~andreserl/maas/lp1591093_1.9 into lp:~maas-committers/maas/trunk

[Andres Rodriguez]

Use the correct repository URL for hpdsa in drivers.yaml.

[Andres Rodriguez (andreserl)]

Self approving as this was approved in: https://code.launchpad.net/~andreserl/maas/fix_hdpsa_repo2/+merge/297086

review: Approve

=== modified file 'Makefile'
--- Makefile	2016-05-25 16:48:25 +0000
+++ Makefile	2016-06-10 16:34:39 +0000
@@ -527,8 +527,8 @@
 # this.
 
 # Old names.
-PACKAGING := $(abspath ../packaging.trunk)
-PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging
+PACKAGING := $(abspath ../packaging-1.9)
+PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging-1.9
 
 packaging-tree = $(PACKAGING)
 packaging-branch = $(PACKAGING_BRANCH)

=== modified file 'contrib/maas-http.conf'
--- contrib/maas-http.conf	2016-03-28 13:54:47 +0000
+++ contrib/maas-http.conf	2016-06-10 16:34:39 +0000
@@ -26,7 +26,7 @@
 
 <IfModule proxy_module>
     ProxyPreserveHost on
-    ProxyPass /MAAS/ws "ws://localhost:5240/MAAS/ws"
+    ProxyPass /MAAS/ws "ws://localhost:5240/MAAS/ws" disablereuse=on
     ProxyPass /MAAS/static/ !
     ProxyPass /MAAS/ http://localhost:5240/MAAS/
     ProxyPass /MAAS http://localhost:5240/MAAS/

=== modified file 'contrib/preseeds_v2/enlist_userdata'
--- contrib/preseeds_v2/enlist_userdata	2016-04-22 17:44:18 +0000
+++ contrib/preseeds_v2/enlist_userdata	2016-06-10 16:34:39 +0000
@@ -159,10 +159,45 @@
       sleep 60
       [ -e $bfile ] && exit 0
    fi
-
-
-
-packages: [ freeipmi-tools, openipmi, ipmitool, archdetect-deb ]
+<<<<<<< TREE
+
+
+
+packages: [ freeipmi-tools, openipmi, ipmitool, archdetect-deb ]
+=======
+ - &write_poweroff_job |
+   cat >/etc/init/maas-poweroff.conf <<EOF
+   description "poweroff when maas task is done"
+   start on stopped cloud-final
+   console output
+   task
+   script
+     [ ! -e /tmp/block-poweroff ] || exit 0
+     poweroff
+   end script
+   EOF
+   # reload required due to lack of inotify in overlayfs (LP: #882147)
+   initctl reload-configuration
+ - &write_systemd_poweroff_job |
+   cat >/lib/systemd/system/maas-poweroff.service <<EOF
+   [Unit]
+   Description=Poweroff when maas task is done
+   Wants=cloud-final.service
+   After=cloud-final.service
+   ConditionPathExists=!/tmp/block-poweroff
+
+   [Service]
+   ExecStart=/sbin/poweroff
+   EOF
+   # reload required due to lack of inotify in overlayfs (LP: #882147)
+   if [ -d /run/systemd/system ]; then
+       systemctl daemon-reload
+   fi
+
+
+
+packages: [ freeipmi-tools, openipmi, ipmitool, archdetect-deb ]
+>>>>>>> MERGE-SOURCE
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
 runcmd:
  - [ sh, -c, *maas_enlist ]

=== modified file 'docs/changelog.rst'
--- docs/changelog.rst	2016-06-04 14:37:29 +0000
+++ docs/changelog.rst	2016-06-10 16:34:39 +0000
@@ -2,6 +2,7 @@
 Changelog
 =========
 
+<<<<<<< TREE
 2.0.0 (beta6)
 =============
 
@@ -1155,6 +1156,400 @@
 
 LP: #1510457    [UI] No error message if there is no boot and/or root disk configured for a node.
 
+=======
+1.9.4
+=====
+
+LP: #1584850    [1.9] DNS record added for non-boot interface IP when no address of that family exists on the boot interface
+
+LP: #1583715    [1.9] Ensure that restricted resources also perform meaningful authentication of clients.
+
+LP: #1584211    [1.9] Exclude RAM, floppy, and loopback devices from lsblk during commissioning.
+
+LP: #1585400    [1.9] Change detect_missing_packages in moonshot power driver to look for `ipmitool` instead of `ipmipower`
+
+LP: #1581318    [1.9] Append version to templateUrl in maas.js angular code.
+
+LP: #1591093    [2.0,1.9] 3rd party HP drivers (archive hostname renamed) - deployment fails
+
+
+1.9.3
+=====
+
+See https://launchpad.net/maas/+milestone/1.9.3 for full details.
+
+Bug Fix Update
+--------------
+
+LP: #1521618    [1.9] wrong subnet in DHCP answer when multiple networks are present
+
+LP: #1536604    [1.9] IntegrityError while uploading leases - when there are reserved IP's on the dynamic range
+
+LP: #1580712    [1.9] dhcp update error: str object has no attribute mac
+
+LP: #1575567    [1.9] Re-commissioning doesn't detect storage changes
+
+LP: #1576194    [1.9] Enlistment via DHCP fails because DNS has bogus PTR record
+
+
+1.9.2
+=====
+
+See https://launchpad.net/maas/+milestone/1.9.2 for full details.
+
+Bug Fix Update
+--------------
+
+LP: #1573219    Deleting user in UI leads to 500
+
+LP: #1508741    IPMI driver does not handle timeouts correctly
+
+LP: #1572070    MAAS 2.0 cannot link physical device interfaces to tagged vlans, breaking juju 2.0 multi-NIC containers
+
+LP: #1573046    14.04 images not available for commissioning as distrio-info --lts now reports xenial
+
+LP: #1571563    Can't override built in partitioning
+
+LP: #1552923    API allows attaching physical, bond interface to VLAN with a known tag (Inconsistent with UI)
+
+LP: #1566336    MAAS keeps IPs assigned to eth0, even after eth0 is enslaved into a bond
+
+LP: #1543195    unable to set mtu on default VLAN
+
+LP: #1560693    Migration 0188 dist-upgrade update failure
+
+LP: #1554747    CPU Utilization of postgresql thread reaches 100% for deleting a node from MaaS
+
+LP: #1499934    Power state could not be queried (vmware)
+
+LP: #1543707    MAAS 1.9+ should not allow whitespace characters in space names
+
+LP: #1543968    MAAS 1.9.0 allows non-unique space names
+
+LP: #1567213    devices results missing interface_set
+
+LP: #1568051    ThreadPool context entry failure causes thread pool to break
+
+LP: #1212205    get_file_by_name does not check owner
+
+LP: #1298772    MAAS API vulnerable to CSRF attack
+
+LP: #1379826    uuid.uuid1() is not suitable as an unguessable identifier/token
+
+LP: #1573264    Enlistment fails: archdetect not found.
+
+LP: #1556219    Discover correct IPMI driver in Power8.
+
+
+1.9.1
+=====
+
+See https://launchpad.net/maas/+milestone/1.9.1 for full details.
+
+Bug Fix Update
+--------------
+
+LP: #1523779    Fix grub-install error on deploying power8 machines.
+
+LP: #1526542    Skip block devices with duplicate serial numbers to fix multipath issue.
+
+LP: #1532262    Fix failure to power query requests for SM15K servers.
+
+LP: #1484696    Fix bug in apache2 maas config where it will reuse websocket connections to work around a bug in apache2 itself.
+
+
+1.9.0
+=====
+
+Important announcements
+-----------------------
+
+**New Networking Concepts and API's: Fabrics, Spaces and Subnets**
+ With the introduction of new MAAS networking concepts, new API's are also
+ been introduced. These are:
+
+  * fabrics
+  * spaces
+  * subnets
+  * vlans
+  * fan-networks
+
+ MAAS 1.9.0 will continue to provide backwards compatibility with the old
+ network API for reading purposes, but moving forward, users are required to
+ use the new API to manipulate fabrics, spaces and subnets.
+
+**Advanced Network and Storage Configuration only available for Ubuntu deployments**
+ Users can now perform advanced network and storage configurations for nodes
+ before deployment. The advanced configuration is only available for Ubuntu
+ deployments. All other deployments using third party OS', including CentOS,
+ RHEL, Windows and Custom Images, won't result in such configuration.
+
+**Re-commissioning required for upgraded MAAS**
+ Now that storage partitioning and advanced configuration is supported natively,
+ VM nodes in MAAS need to be re-commissioned.
+
+  * If upgrading from MAAS 1.8, only VM nodes with VirtIO storage devices need
+    to be re-commissioned.
+
+  * If upgrading from MAAS 1.7, all nodes will need to be re-commissioned in
+    order for MAAS to correctly capture the storage and networking devices.
+
+ This does not affect nodes that are currently deployed.
+
+**Default Storage Partitioning Layout - Flat**
+ With the introduction of custom storage, MAAS has also introduced the concept
+ of partitioning layouts. Partitioning layouts allow the user to quickly
+ auto-configure the disk partitioning scheme after first commissioning or
+ re-commissioning (if selected to do so). The partitioning layouts are set
+ globally on the `Settings` page.
+
+ The current default Partitioning layout is 'Flat', maintaining backwards
+ compatibility with previous MAAS releases. This means MAAS will take the
+ first disk it finds in the system and use it as the root and boot disk.
+
+**Deployment with configured /etc/network/interfaces**
+ Starting with MAAS 1.9, all node deployments will result in writing
+ `/etc/network/interfaces` statically, by default. This increases MAAS'
+ robustness and reliability as users no longer have to depend on DHCP for
+ IP address allocation solely.
+
+ MAAS will continue to provide IP addresses via DHCP, even though interfaces
+ in `/etc/network/interfaces` may have been configured statically.
+
+Major new features
+------------------
+
+**Storage Partitioning and Advanced Configuration**
+ MAAS now supports Storage Partitioning and Advanced Configuration natively.
+ This allows MAAS to deploy machines with different Storage Layouts, as
+ well as different complex partitioning configurations. Storage support
+ includes:
+
+ * LVM
+ * Bcache
+ * Software RAID levels 0, 1, 5, 6, 10.
+ * Advanced partitioning
+
+ Storace configuration is available both via the WebUI and API. For more
+ information refer to :ref:`storage`.
+
+**Advanced Networking (Fabrics, Spaces, Subnetworks) and Node Network Configuration**
+ MAAS now supports Advanced Network configuration, allowing users to not
+ only perform advanced node network configuration, but also allowing users
+ to declare and map their infrastructure in the form of Fabrics, VLANs,
+ Spaces and Subnets.
+
+ **Fabrics, Spaces, Subnets and Fan networks**
+  MAAS now supports the concept of Fabrics, Spaces, Subnets and FANS,
+  which introduce a whole new way of declaring and mapping your network
+  and infrastructure in MAAS.
+
+  The MAAS WebUI allows users to view all the declared Fabrics, Spaces,
+  VLANs inside fabrics and Subnets inside Spaces. The WebUI does not yet
+  support the ability to create new of these, but the API does.
+
+  These new concepts replace the old `Network` concepts from MAAS'
+  earlier versions. For more information, see :ref:`networking`.
+
+  For more information about the API, see :ref:`api`.
+
+ **Advanced Node Networking Configuration**
+  MAAS can now perform the Node's networking configuration. Doing so,
+  results in `/etc/network/interfaces` being written. Advanced
+  configuration includes:
+
+   * Assign subnets, fabrics, and IP to interfaces.
+   * Create VLAN interfaces.
+   * Create bond interfaces.
+   * Change interface names.
+
+  MAAS also allows configuration of node interfaces in different modes:
+
+   * Auto Assign - Node interface will be configured statically
+     and MAAS will auto assign an IP address.
+   * DHCP - The node interface will be configured to DHCP.
+   * Static - The user will be able to specify what IP address the
+     interface will obtain, while MAAS will configure it statically.
+   * Unconfigured - MAAS will leave the interface with LINK UP.
+
+**Curtin & cloud-init status updates**
+ Starting from MAAS 1.9.0, curtin and cloud-init will now send messages
+ to MAAS providing information regarding various of the actions being
+ taken. This information will be displayed in MAAS in the `Node Event Log`.
+
+ Note that this information is only available when using MAAS 1.9.0 and
+ the latest version fo curtin. For cloud-init messages this information
+ is only available when deploying Wily+.
+
+**Fabric and subnet creation**
+ MAAS now auto-creates multiple fabrics per physical interface connected
+ to the Cluster Controller, and will correctly create subnetworks under
+ each fabric, as well as VLAN's, if any of the Cluster Controller
+ interface is a VLAN interface.
+
+**HWE Kernels**
+ MAAS now has a different approach to deploying Hardware Enablement
+ Kernels. Start from MAAS 1.9, the HWE kernels are no longer coupled
+ to subarchitectures of a machine. For each Ubuntu release, users
+ will be able to select any of the available HWE kernels for such
+ release, as well as set the minimum kernel the machine will be
+ deployed with by default.
+
+ For more information, see :ref:`hardware-enablement-kernels`.
+
+**CentOS images can be imported automatically**
+ CentOS Image (CentOS 6 and 7) can now be imported automatically from the
+ MAAS Images page. These images are currently part of the daily streams.
+
+ In order to test this images, you need to use the daily image stream.
+ This can be changed in the `Settings` page under `Boot Images` to
+ `http://maas.ubuntu.com/images/ephemeral-v2/daily/`. Once changed, images
+ can be imported from the MAAS Images page. The CentOS image will be
+ published in the Releases stream shortly.
+
+
+Minor notable changes
+---------------------
+
+**Minimal Config Files for Daemons**
+ Starting from MAAS 1.9, minimal configuration files have been introduced
+ for both, the MAAS Region Controller and the MAAS Cluster Controller daemons.
+
+ *  The Region Controller (`maas-regiond`) has now dropped the usage of
+    `/etc/maas/maas_local_settings.py` in favor of `/etc/maas/regiond.conf`.
+    Available configuration options are now `database_host`, `database_name`,
+    `database_user`, `database_pass`, `maas_url`. MAAS will attempt to migrate
+    any configuration on upgrade, otherwise it will use sane defaults.
+
+ *  The Cluster Controller (`maas-clusterd`) has now dropped the usage of
+    `/etc/maas/pserv.yaml` and `/etc/maas/maas_cluster.conf` in favor of
+    `/etc/maas/clusterd.conf`. Available configuration options are now `maas_url`
+    and `cluster_uuid` only. MAAS will attempt to migrate any configuration
+    on upgrade, otherwise it will use sane defaults.
+
+**Commissioning Actions**
+ MAAS now supports commissioning actions. These allow the user to specify
+ how commissioning should behave in certain escenarios. The commissioning
+ actions available are:
+
+  * Enable SSH during commissioning & Keep machine ON after commissioning
+  * Keep network configuration after commissioning
+  * Keep storage configuration after commissioning
+
+**Warn users about missing power control tools**
+ MAAS now warns users about the missing power control tools. Each MAAS
+ power driver use a set of power tools that may or may not be installed
+ by default. If these power tools are missing from the system, MAAS will
+ warn users.
+
+**Python Power Drivers**
+ Starting from MAAS 1.9, MAAS is moving away from using shell scripts
+ templates for Power Drivers. These are being migrated to MAAS'
+ internal control as power drivers. Currently supported are APC, MSCM,
+ MSFT OCS, SM15k, UCSM, Virsh, VMWare and IPMI.
+
+ Remaining Power Drivers include AMT, Fence CDU's, Moonshot.
+
+Known Problems & Workarounds
+----------------------------
+
+**Garbage in the UI after upgrade**
+ When upgrading from any earlier release (1.5, 1.7, 1.8), the user may see
+ garbage in the UI. This is because the local cache is dirty and won't be
+ refreshed automatically. MAAS 1.9.0 introduced a mechanism to refresh the
+ cache automatically, but this will only take into effect upgrading from
+ 1.9.0 to any later release.
+
+ To work around this issue, the only thing required is to refresh the
+ browsers cache, by hitting F5.
+
+ See bug `1515380`_ for more information.
+
+.. _1515380:
+  https://launchpad.net/bugs/1515380
+
+
+Major bugs fixed in this release
+--------------------------------
+
+See https://launchpad.net/maas/+milestone/1.9.0 for details.
+
+
+1.9.0 (RC4)
+============
+
+Major bugs fixed in this release
+--------------------------------
+
+LP: #1523674    Virsh is reporting ppc64le, not ppc64el.
+
+LP: #1524091    Don't require DHCP to be on if it should be off.
+
+LP: #1523988    No required packages for HMC as it uses pure python paramiko ssh client.
+
+LP: #1524007    Don't hold the cluster configuration lock while reloading boot images.
+
+LP: #1524924    Fix commissioning to correctly identify secondary subnets, VLAN's and fabrics.
+
+
+1.9.0 (RC3)
+=============
+
+Major bugs fixed in this release
+--------------------------------
+
+LP: #1522898    "node-interface" API should just be "interface" - to allow devices to use it
+
+LP: #1519527    Juju 1.25.1 proposed: lxc units all have the same IP address after upgrade from 1.7/1.8.
+
+LP: #1522294    MAAS fails to parse some DHCP leases.
+
+LP: #1519090    DHCP interface automatically obtains an IP even when the subnet is unmanaged.
+
+LP: #1519077    MAAS assigns IP addresses on unmanaged subnets without consideration for some addresses known to be in use.
+
+LP: #1519396    MTU field is not exposed over the API for VLAN.
+
+LP: #1521833    Updating subnet name removes dns_server.
+
+LP: #1519919    CC looks for NICs with kernel module loaded and fall back doesn't check persistent device names.
+
+LP: #1522225    Migration 0181 can fail on upgrade if disks across nodes have duplicate serial numbers.
+
+LP: #1519247    Migration 0146 can fail on upgrade when migrating unmanaged subnets.
+
+LP: #1519397    [UI] Once a cache_set is created the UI fails with ERROR.
+
+LP: #1519918    [UI] "failed to detect a valid IP address" when trying to view node details.
+
+
+1.9.0 (RC2)
+=============
+
+Major bugs fixed in this release
+--------------------------------
+
+LP: #1513085    Partitioning should align for performance.
+
+LP: #1516815    MAAS creates DNS record against Alias (eth0:1) if alias belongs to the PXE Interface.
+
+LP: #1515769    Failed to power on SM15k.
+
+LP: #1516722    Fix migration that might affect upgrade from 1.7.
+
+LP: #1516065    Failed to power control IPMI BMC that does not support setting the boot order.
+
+LP: #1517097    Constraints for acquiring interfaces argument should 'AND' key-value pairs for the same label.
+
+LP: #1517687    [UI] Cannot create a partition using the whole disk.
+
+LP: #1513258    [UI] CSS Broken for Bond Network Device.
+
+LP: #1516173    [UI] Prevent being able to unmount/remove filesystems while node is on.
+
+LP: #1510457    [UI] No error message if there is no boot and/or root disk configured for a node.
+
+>>>>>>> MERGE-SOURCE
 
 1.9.0 (RC1)
 =============

=== modified file 'etc/maas/drivers.yaml'
--- etc/maas/drivers.yaml	2015-09-24 16:22:12 +0000
+++ etc/maas/drivers.yaml	2016-06-10 16:34:39 +0000
@@ -45,7 +45,7 @@
   - 'pci:v00001137d00000046sv*sd*bc*sc*i*'
   module: snic
   package: snic-dkms
-  repository: http://ppa.launchpad.net/cisco-ucs-team/snic-stable/ubuntu 
+  repository: http://ppa.launchpad.net/cisco-ucs-team/snic-stable/ubuntu
 - blacklist: ahci
   comment: HPDSA driver
   key_binary: !!binary |
@@ -75,4 +75,4 @@
   - 'pci:v0000103Cd0000193Fsv0000103Csd00003381bc*sc*i*'
   module: hpdsa
   package: hpdsa-dkms
-  repository: http://downloads.linux.hp.com/SDR/repo/ubuntu-hpdsa
+  repository: http://downloads.linux.hpe.com/SDR/repo/ubuntu-hpdsa

=== modified file 'etc/maas/templates/commissioning-user-data/snippets/maas_ipmi_autodetect.py'
=== modified file 'etc/maas/templates/commissioning-user-data/snippets/tests/test_maas_ipmi_autodetect.py'
=== modified file 'src/maas/settings.py'
=== modified file 'src/maasserver/api/devices.py'
--- src/maasserver/api/devices.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/api/devices.py	2016-06-10 16:34:39 +0000
@@ -7,6 +7,7 @@
     ]
 
 from maasserver.api.logger import maaslog
+<<<<<<< TREE
 from maasserver.api.nodes import (
     NodeHandler,
     NodesHandler,
@@ -15,6 +16,24 @@
 from maasserver.api.support import operation
 from maasserver.enum import NODE_PERMISSION
 from maasserver.exceptions import MAASAPIValidationError
+=======
+from maasserver.api.support import (
+    operation,
+    OperationsHandler,
+)
+from maasserver.api.utils import get_optional_list
+from maasserver.enum import (
+    INTERFACE_LINK_TYPE,
+    IPADDRESS_TYPE,
+    NODE_PERMISSION,
+)
+from maasserver.exceptions import (
+    MAASAPIBadRequest,
+    MAASAPIValidationError,
+    StaticIPAddressExhaustion,
+)
+from maasserver.fields import MAC_RE
+>>>>>>> MERGE-SOURCE
 from maasserver.forms import (
     DeviceForm,
     DeviceWithMACsForm,
@@ -156,8 +175,122 @@
             device_system_id = device.system_id
         return ('device_handler', (device_system_id,))
 
+<<<<<<< TREE
 
 class DevicesHandler(NodesHandler):
+=======
+    @operation(idempotent=False)
+    def claim_sticky_ip_address(self, request, system_id):
+        """Assign a "sticky" IP address to a device's MAC.
+
+        :param mac_address: Optional MAC address on the device on which to
+            assign the sticky IP address.  If not passed, defaults to the
+            primary MAC for the device.
+        :param requested_address: Optional IP address to claim.  If this
+            isn't passed, this method will draw an IP address from the static
+            range of the cluster interface this MAC is related to.
+            If passed, this method lets you associate any IP address
+            with a MAC address if the MAC isn't related to a cluster interface.
+
+        Returns 404 if the device is not found.
+        Returns 400 if the mac_address is not found on the device.
+        Returns 503 if there are not enough IPs left on the cluster interface
+        to which the mac_address is linked.
+        Returns 503 if the interface does not have an associated subnet.
+        Returns 503 if the requested_address falls in a dynamic range.
+        Returns 503 if the requested_address is already allocated.
+        """
+        device = Device.objects.get_node_or_404(
+            system_id=system_id, user=request.user, perm=NODE_PERMISSION.EDIT)
+        form = ClaimIPForMACForm(request.POST)
+
+        if not form.is_valid():
+            raise MAASAPIValidationError(form.errors)
+        else:
+            raw_mac = request.POST.get('mac_address', None)
+            if raw_mac is None:
+                interface = device.get_boot_interface()
+            else:
+                try:
+                    interface = Interface.objects.get(
+                        mac_address=raw_mac, node=device)
+                except Interface.DoesNotExist:
+                    raise MAASAPIBadRequest(
+                        "mac_address %s not found on the device" % raw_mac)
+            requested_address = request.POST.get('requested_address', None)
+            if requested_address is None:
+                sticky_ips = interface.claim_static_ips()
+            else:
+                subnet = Subnet.objects.get_best_subnet_for_ip(
+                    requested_address)
+                sticky_ips = [
+                    interface.link_subnet(
+                        INTERFACE_LINK_TYPE.STATIC, subnet,
+                        ip_address=requested_address),
+                ]
+
+            if len(sticky_ips) == 0:
+                raise StaticIPAddressExhaustion(
+                    "%s: An IP address could not be claimed at this time. "
+                    "Check your subnet ranges and utilization and try again." %
+                    device.hostname)
+            else:
+                maaslog.info(
+                    "%s: Sticky IP address(es) allocated: %s", device.hostname,
+                    ', '.join(allocation.ip for allocation in sticky_ips))
+
+            return device
+
+    @operation(idempotent=False)
+    def release_sticky_ip_address(self, request, system_id):
+        """Release a "sticky" IP address from a device's MAC.
+
+        :param address: Optional IP address to release. If left unspecified,
+            will release every "sticky" IP address associated with the device.
+
+        Returns 400 if the specified addresses could not be deallocated
+        Returns 404 if the device is not found.
+        """
+        device = Device.objects.get_node_or_404(
+            system_id=system_id, user=request.user, perm=NODE_PERMISSION.EDIT)
+        form = ReleaseIPForm(request.POST)
+
+        if not form.is_valid():
+            raise MAASAPIValidationError(form.errors)
+
+        address = request.POST.get('address', None)
+        if address is not None and address.strip() == '':
+            raise MAASAPIBadRequest(
+                {'address': ["Cannot be empty if supplied."]})
+
+        deallocated_ips = []
+        if address:
+            sip = StaticIPAddress.objects.filter(
+                alloc_type=IPADDRESS_TYPE.STICKY, ip=address,
+                interface__node=device).first()
+            if sip is None:
+                raise MAASAPIBadRequest(
+                    "%s is not a sticky IP address on device: %s",
+                    address, device.hostname)
+            for interface in sip.interface_set.all():
+                interface.unlink_ip_address(sip)
+            deallocated_ips.append(address)
+        else:
+            for interface in device.interface_set.all():
+                for ip_address in interface.ip_addresses.filter(
+                        alloc_type=IPADDRESS_TYPE.STICKY, ip__isnull=False):
+                    if ip_address.ip:
+                        interface.unlink_ip_address(ip_address)
+                        deallocated_ips.append(ip_address.ip)
+
+        maaslog.info(
+            "%s: Sticky IP address(es) deallocated: %s", device.hostname,
+            ', '.join(unicode(ip) for ip in deallocated_ips))
+        return device
+
+
+class DevicesHandler(OperationsHandler):
+>>>>>>> MERGE-SOURCE
     """Manage the collection of all the devices in the MAAS."""
     api_doc_section_name = "Devices"
     update = delete = None

=== modified file 'src/maasserver/api/files.py'
=== modified file 'src/maasserver/api/interfaces.py'
--- src/maasserver/api/interfaces.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/api/interfaces.py	2016-06-10 16:34:39 +0000
@@ -75,6 +75,7 @@
             "Cannot %s interface because the node is not Ready." % operation)
 
 
+<<<<<<< TREE
 def raise_error_if_controller(node, operation):
     if node.is_controller:
         raise MAASAPIForbidden(
@@ -84,6 +85,11 @@
 class InterfacesHandler(OperationsHandler):
     """Manage interfaces on a node."""
     api_doc_section_name = "Interfaces"
+=======
+class InterfacesHandler(OperationsHandler):
+    """Manage interfaces on a node or device."""
+    api_doc_section_name = "Interfaces"
+>>>>>>> MERGE-SOURCE
     create = update = delete = None
     fields = DISPLAYED_INTERFACE_FIELDS
 
@@ -93,8 +99,12 @@
         return ('interfaces_handler', ["system_id"])
 
     def read(self, request, system_id):
+<<<<<<< TREE
         """List all interfaces belonging to a machine, device, or
         rack controller.
+=======
+        """List all interfaces belonging to a node or device.
+>>>>>>> MERGE-SOURCE
 
         Returns 404 if the node is not found.
         """
@@ -104,7 +114,11 @@
 
     @operation(idempotent=False)
     def create_physical(self, request, system_id):
+<<<<<<< TREE
         """Create a physical interface on a machine and device.
+=======
+        """Create a physical interface on a node or device.
+>>>>>>> MERGE-SOURCE
 
         :param name: Name of the interface.
         :param mac_address: MAC address of the interface.
@@ -119,6 +133,7 @@
 
         Returns 404 if the node is not found.
         """
+<<<<<<< TREE
         node = Node.objects.get_node_or_404(
             system_id, request.user, NODE_PERMISSION.EDIT)
         raise_error_if_controller(node, "create")
@@ -126,6 +141,14 @@
         if node.node_type == NODE_TYPE.MACHINE:
             raise_error_for_invalid_state_on_allocated_operations(
                 node, request.user, "create")
+=======
+        node = Node.objects.get_node_or_404(
+            system_id, request.user, NODE_PERMISSION.EDIT)
+        # Installable nodes require the node needs to be in the correct state.
+        if node.installable:
+            raise_error_for_invalid_state_on_allocated_operations(
+                node, request.user, "create")
+>>>>>>> MERGE-SOURCE
         form = PhysicalInterfaceForm(node=node, data=request.data)
         if form.is_valid():
             return form.save()
@@ -386,6 +409,7 @@
         Returns 404 if the node or interface is not found.
         """
         interface = Interface.objects.get_interface_or_404(
+<<<<<<< TREE
             system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
         node = interface.get_node()
         if node.node_type == NODE_TYPE.MACHINE:
@@ -400,6 +424,15 @@
             interface_form = ControllerInterfaceForm
         else:
             interface_form = InterfaceForm.get_interface_form(interface.type)
+=======
+            system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
+        if interface.get_node().installable:
+            # This node needs to be in the correct state to modify
+            # the interface.
+            raise_error_for_invalid_state_on_allocated_operations(
+                interface.node, request.user, "update interface")
+        interface_form = InterfaceForm.get_interface_form(interface.type)
+>>>>>>> MERGE-SOURCE
         # For VLAN interface we cast parents to parent. As a VLAN can only
         # have one parent.
         if interface.type == INTERFACE_TYPE.VLAN:
@@ -423,6 +456,7 @@
         Returns 404 if the node or interface is not found.
         """
         interface = Interface.objects.get_interface_or_404(
+<<<<<<< TREE
             system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
         node = interface.get_node()
         raise_error_if_controller(node, "delete interface")
@@ -431,6 +465,14 @@
             # the interface.
             raise_error_for_invalid_state_on_allocated_operations(
                 interface.node, request.user, "delete interface")
+=======
+            system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
+        if interface.get_node().installable:
+            # This node needs to be in the correct state to modify
+            # the interface.
+            raise_error_for_invalid_state_on_allocated_operations(
+                interface.node, request.user, "delete interface")
+>>>>>>> MERGE-SOURCE
         interface.delete()
         return rc.DELETED
 
@@ -466,6 +508,7 @@
         Returns 404 if the node or interface is not found.
         """
         interface = Interface.objects.get_interface_or_404(
+<<<<<<< TREE
             system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
         node = interface.get_node()
         raise_error_if_controller(node, "link subnet")
@@ -485,6 +528,26 @@
             allowed_modes = [INTERFACE_LINK_TYPE.STATIC]
         form = InterfaceLinkForm(
             instance=interface, data=request.data, allowed_modes=allowed_modes)
+=======
+            system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
+        node = interface.get_node()
+        if node.installable:
+            # This node needs to be in the correct state to modify
+            # the interface.
+            raise_error_for_invalid_state_on_allocated_operations(
+                interface.node, request.user, "link subnet")
+            allowed_modes = [
+                INTERFACE_LINK_TYPE.AUTO,
+                INTERFACE_LINK_TYPE.DHCP,
+                INTERFACE_LINK_TYPE.STATIC,
+                INTERFACE_LINK_TYPE.LINK_UP,
+            ]
+        else:
+            # Devices can only be set in static IP mode.
+            allowed_modes = [INTERFACE_LINK_TYPE.STATIC]
+        form = InterfaceLinkForm(
+            instance=interface, data=request.data, allowed_modes=allowed_modes)
+>>>>>>> MERGE-SOURCE
         if form.is_valid():
             return form.save()
         else:
@@ -499,6 +562,7 @@
         Returns 404 if the node or interface is not found.
         """
         interface = Interface.objects.get_interface_or_404(
+<<<<<<< TREE
             system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
         node = interface.get_node()
         raise_error_if_controller(node, "link subnet")
@@ -507,6 +571,14 @@
             # the interface.
             raise_error_for_invalid_state_on_allocated_operations(
                 node, request.user, "unlink subnet")
+=======
+            system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
+        if interface.get_node().installable:
+            # This node needs to be in the correct state to modify
+            # the interface.
+            raise_error_for_invalid_state_on_allocated_operations(
+                interface.node, request.user, "unlink subnet")
+>>>>>>> MERGE-SOURCE
         form = InterfaceUnlinkForm(instance=interface, data=request.data)
         if form.is_valid():
             return form.save()
@@ -528,6 +600,7 @@
         Returns 404 if the node or interface is not found.
         """
         interface = Interface.objects.get_interface_or_404(
+<<<<<<< TREE
             system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
         node = interface.get_node()
         raise_error_if_controller(node, "link subnet")
@@ -536,6 +609,14 @@
             # the interface.
             raise_error_for_invalid_state_on_allocated_operations(
                 node, request.user, "set default gateway")
+=======
+            system_id, interface_id, request.user, NODE_PERMISSION.EDIT)
+        if interface.get_node().installable:
+            # This node needs to be in the correct state to modify
+            # the interface.
+            raise_error_for_invalid_state_on_allocated_operations(
+                interface.node, request.user, "set default gateway")
+>>>>>>> MERGE-SOURCE
         form = InterfaceSetDefaultGatwayForm(
             instance=interface, data=request.data)
         if form.is_valid():
@@ -543,6 +624,7 @@
         else:
             raise MAASAPIValidationError(form.errors)
 
+<<<<<<< TREE
     @operation(idempotent=False)
     def add_tag(self, request, system_id, interface_id):
         """Add a tag to interface on a node.
@@ -575,6 +657,20 @@
 
 
 class PhysicaInterfaceHandler(InterfaceHandler):
+=======
+
+class NodeInterfacesHandler(InterfacesHandler):
+    """Manage interfaces on a node. (Deprecated)"""
+    api_doc_section_name = "Node Interfaces"
+
+
+class NodeInterfaceHandler(InterfaceHandler):
+    """Manage a node's interface. (Deprecated)"""
+    api_doc_section_name = "Node Interface"
+
+
+class PhysicaInterfaceHandler(InterfaceHandler):
+>>>>>>> MERGE-SOURCE
     """
     This handler only exists because piston requires a unique handler per
     class type. Without this class the resource_uri will not be added to any

=== modified file 'src/maasserver/api/support.py'
--- src/maasserver/api/support.py	2016-05-20 14:31:34 +0000
+++ src/maasserver/api/support.py	2016-06-10 16:34:39 +0000
@@ -16,9 +16,15 @@
 from django.http import Http404
 from maasserver.api.doc import get_api_description_hash
 from maasserver.exceptions import MAASAPIBadRequest
+<<<<<<< TREE
 from piston3.authentication import NoAuthentication
 from piston3.emitters import Emitter
 from piston3.handler import (
+=======
+from piston.authentication import NoAuthentication
+from piston.emitters import Emitter
+from piston.handler import (
+>>>>>>> MERGE-SOURCE
     AnonymousBaseHandler,
     BaseHandler,
     HandlerMetaClass,
@@ -82,6 +88,7 @@
 class RestrictedResource(OperationsResource):
     """A resource that's restricted to active users."""
 
+<<<<<<< TREE
     def __init__(self, handler, *, authentication):
         """A value for `authentication` MUST be provided AND be meaningful.
 
@@ -97,6 +104,23 @@
         if not self.is_authentication_attempted:
             raise AssertionError("Authentication must be attempted.")
 
+=======
+    def __init__(self, handler, authentication):
+        """A value for `authentication` MUST be provided AND be meaningful.
+
+        This prevents the situation where none of the following are restricted
+        at all::
+
+          handler = RestrictedResource(HandlerClass)
+          handler = RestrictedResource(HandlerClass, authentication=None)
+          handler = RestrictedResource(HandlerClass, authentication=[])
+
+        """
+        super(RestrictedResource, self).__init__(handler, authentication)
+        if not self.is_authentication_attempted:
+            raise AssertionError("Authentication must be attempted.")
+
+>>>>>>> MERGE-SOURCE
     def authenticate(self, request, rm):
         actor, anonymous = super(
             RestrictedResource, self).authenticate(request, rm)

=== modified file 'src/maasserver/api/tests/test_devices.py'
--- src/maasserver/api/tests/test_devices.py	2016-05-24 22:05:45 +0000
+++ src/maasserver/api/tests/test_devices.py	2016-06-10 16:34:39 +0000
@@ -11,15 +11,35 @@
 from django.core.urlresolvers import reverse
 from maasserver.enum import (
     NODE_STATUS,
+<<<<<<< TREE
     NODE_TYPE,
+=======
+    NODEGROUP_STATUS,
+    NODEGROUPINTERFACE_MANAGEMENT,
+>>>>>>> MERGE-SOURCE
 )
 from maasserver.models import (
+<<<<<<< TREE
     Device,
     Domain,
     node as node_module,
 )
 from maasserver.testing.api import APITestCase
+=======
+    Device,
+    Interface,
+    interface as interface_module,
+    Node,
+    NodeGroup,
+    StaticIPAddress,
+)
+from maasserver.testing.api import (
+    APITestCase,
+    APITransactionTestCase,
+)
+>>>>>>> MERGE-SOURCE
 from maasserver.testing.factory import factory
+<<<<<<< TREE
 from maasserver.utils.converters import json_load_bytes
 from maasserver.utils.orm import reload_object
 from maastesting.matchers import MockCalledOnce
@@ -42,6 +62,17 @@
 
 
 class TestDevicesAPI(APITestCase.ForUser):
+=======
+from maasserver.testing.orm import reload_object
+from mock import patch
+from testtools.matchers import (
+    HasLength,
+    Not,
+)
+
+
+class TestDevicesAPI(APITestCase):
+>>>>>>> MERGE-SOURCE
 
     def test_handler_path(self):
         self.assertEqual(
@@ -348,6 +379,7 @@
         device = factory.make_Node(
             node_type=NODE_TYPE.DEVICE, owner=factory.make_User())
         response = self.client.delete(get_device_uri(device))
+<<<<<<< TREE
         self.assertEqual(http.client.FORBIDDEN, response.status_code)
         self.assertEqual(device, reload_object(device))
 
@@ -392,3 +424,392 @@
             {'op': 'restore_default_configuration'})
         self.assertEqual(
             http.client.FORBIDDEN, response.status_code, response.content)
+=======
+        self.assertEqual(httplib.FORBIDDEN, response.status_code)
+        self.assertEquals(device, reload_object(device))
+
+
+class TestClaimStickyIpAddressAPI(APITestCase):
+    """Tests for /api/1.0/devices/?op=claim_sticky_ip_address."""
+
+    def test__claims_ip_address_from_cluster_interface_static_range(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_from_unmanaged_cluster_interface(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_from_detached_cluster_interface(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        subnet = ngi.subnet
+        ngi.subnet = None
+        ngi.save()
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=subnet, unmanaged=True)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_after_devices_new(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        # Run 'devices new', as a sanity check to ensure the object is created
+        # the same way as it is when juju does it.
+        self.client.post(
+            reverse('devices_handler'),
+            {
+                'op': 'new',
+                'hostname': "lxc-1",
+                'mac_addresses': "01:02:03:04:05:06",
+                'parent': parent.system_id,
+            })
+        # Silence 'update_host_maps'.
+        device = Device.objects.first()
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        # import pdb; pdb.set_trace()
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__rejected_if_not_permitted(self):
+        parent = factory.make_Node_with_Interface_on_Subnet()
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=factory.make_User())
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.FORBIDDEN, response.status_code)
+
+    def test_creates_ip_with_random_ip(self):
+        requested_address = factory.make_ip_address()
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+                'requested_address': requested_address,
+            })
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        [given_ip] = StaticIPAddress.objects.all()
+        self.assertEqual(
+            (given_ip.ip, requested_address, IPADDRESS_TYPE.STICKY),
+            (returned_ip, returned_ip, given_ip.alloc_type)
+        )
+
+    def test_503_if_no_subnet_found(self):
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+            })
+        self.assertEqual(
+            httplib.SERVICE_UNAVAILABLE, response.status_code,
+            response.content)
+
+    @patch.object(Interface, 'claim_static_ips')
+    def test_503_if_no_ip_found(self, claim_static_ips):
+        claim_static_ips.side_effect = [list()]
+
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+            })
+        self.assertEqual(
+            httplib.SERVICE_UNAVAILABLE, response.status_code,
+            response.content)
+
+    def test_creates_ip_for_specific_mac(self):
+        requested_address = factory.make_ip_address()
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        second_nic = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+                'requested_address': requested_address,
+                'mac_address': unicode(second_nic.mac_address),
+            })
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        [given_ip] = StaticIPAddress.objects.all()
+        self.assertEqual(
+            (given_ip.ip, requested_address, IPADDRESS_TYPE.STICKY),
+            (returned_ip, returned_ip, given_ip.alloc_type)
+        )
+
+    def test_rejects_invalid_ip(self):
+        requested_address = factory.make_name('bogus')
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        interface = device.interface_set.all()[0]
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+                'requested_address': requested_address,
+                'mac_address': interface.mac_address
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+        self.assertEqual(
+            dict(requested_address=["Enter a valid IPv4 or IPv6 address."]),
+            json.loads(response.content))
+
+    def test_rejects_invalid_mac(self):
+        mac_address = factory.make_name('bogus')
+        requested_address = factory.make_ip_address()
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+                'requested_address': requested_address,
+                'mac_address': mac_address
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+        self.assertEqual(
+            dict(
+                mac_address=[
+                    "'%s' is not a valid MAC address." % mac_address]),
+            json.loads(response.content))
+
+    def test_rejects_unrelated_mac(self):
+        # Create an other device.
+        other_device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=factory.make_User())
+        other_nic = other_device.interface_set.all()[0]
+
+        requested_address = factory.make_ip_address()
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+                'requested_address': requested_address,
+                'mac_address': other_nic.mac_address
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+        self.assertItemsEqual([], StaticIPAddress.objects.all())
+
+
+class TestDeviceReleaseStickyIpAddressAPI(APITestCase):
+    """Tests for /api/1.0/devices/?op=release_sticky_ip_address."""
+
+    def test__releases_ip_address(self):
+        parent = factory.make_Node_with_Interface_on_Subnet()
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps' and 'remove_host_maps'
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(interface_module, "remove_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        self.expectThat(parsed_device["ip_addresses"], Not(HasLength(0)))
+
+        response = self.client.post(
+            get_device_uri(device), {'op': 'release_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        self.expectThat(parsed_device["ip_addresses"], HasLength(0))
+
+    def test__rejects_invalid_ip(self):
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'release_sticky_ip_address',
+                'address': factory.make_name('bogus'),
+            })
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+        self.assertEqual(
+            dict(address=["Enter a valid IPv4 or IPv6 address."]),
+            json.loads(response.content))
+
+    def test__rejects_empty_ip(self):
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'release_sticky_ip_address',
+                'address': '',
+            })
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+
+
+class TestDeviceReleaseStickyIpAddressAPITransactional(APITransactionTestCase):
+    '''The following TestDeviceReleaseStickyIpAddressAPI tests require
+        APITransactionTestCase, and thus, have been separated
+        from the TestDeviceReleaseStickyIpAddressAPI above.
+    '''
+    def test__releases_all_ip_addresses(self):
+        network = factory._make_random_network(slash=24)
+        subnet = factory.make_Subnet(cidr=unicode(network.cidr))
+        device = factory.make_Node_with_Interface_on_Subnet(
+            installable=False, subnet=subnet,
+            disable_ipv4=False, owner=self.logged_in_user)
+        for _ in range(4):
+            extra_nic = factory.make_Interface(
+                INTERFACE_TYPE.PHYSICAL, node=device)
+            factory.make_StaticIPAddress(
+                alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+                interface=extra_nic, subnet=subnet)
+        # Silence 'update_host_maps' and 'remove_host_maps'
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(interface_module, "remove_host_maps")
+        self.assertThat(device.interface_set.all(), HasLength(5))
+        for interface in device.interface_set.all():
+            with transaction.atomic():
+                allocated = interface.claim_static_ips()
+            self.expectThat(allocated, HasLength(1))
+        response = self.client.post(
+            get_device_uri(device), {'op': 'release_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        self.expectThat(parsed_device["ip_addresses"], HasLength(0))
+
+    def test__releases_specific_address(self):
+        network = factory._make_random_network(slash=24)
+        subnet = factory.make_Subnet(cidr=unicode(network.cidr))
+        device = factory.make_Node_with_Interface_on_Subnet(
+            installable=False, subnet=subnet,
+            disable_ipv4=False, owner=self.logged_in_user)
+        extra_nic = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            interface=extra_nic, subnet=subnet)
+        # Silence 'update_host_maps' and 'remove_host_maps'
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(interface_module, "remove_host_maps")
+        self.assertThat(device.interface_set.all(), HasLength(2))
+        ips = []
+        for interface in device.interface_set.all():
+            with transaction.atomic():
+                allocated = interface.claim_static_ips()
+            self.expectThat(allocated, HasLength(1))
+            # Note: 'allocated' is a list of (ip,mac) tuples
+            ips.append(allocated[0])
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'release_sticky_ip_address',
+                'address': unicode(ips[0].ip)
+            })
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        self.expectThat(parsed_device["ip_addresses"], HasLength(1))
+
+    def test__rejected_if_not_permitted(self):
+        parent = factory.make_Node_with_Interface_on_Subnet()
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=factory.make_User())
+        # Silence 'update_host_maps' and 'remove_host_maps'
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(interface_module, "remove_host_maps")
+        with transaction.atomic():
+            device.get_boot_interface().claim_static_ips()
+        self.assertThat(
+            StaticIPAddress.objects.filter(alloc_type=IPADDRESS_TYPE.STICKY),
+            HasLength(1))
+        response = self.client.post(
+            get_device_uri(device), {'op': 'release_sticky_ip_address'})
+        self.assertEqual(
+            httplib.FORBIDDEN, response.status_code, response.content)
+        self.assertThat(
+            StaticIPAddress.objects.filter(alloc_type=IPADDRESS_TYPE.STICKY),
+            HasLength(1))
+>>>>>>> MERGE-SOURCE

=== modified file 'src/maasserver/api/tests/test_filestorage.py'
--- src/maasserver/api/tests/test_filestorage.py	2016-05-24 22:05:45 +0000
+++ src/maasserver/api/tests/test_filestorage.py	2016-06-10 16:34:39 +0000
@@ -75,7 +75,11 @@
     def test_get_does_not_work_anonymously(self):
         storage = factory.make_FileStorage()
         response = self.make_API_GET_request("get", storage.filename)
+<<<<<<< TREE
         self.assertEqual(http.client.BAD_REQUEST, response.status_code)
+=======
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+>>>>>>> MERGE-SOURCE
 
     def test_get_by_key_works_anonymously(self):
         storage = factory.make_FileStorage()
@@ -196,13 +200,20 @@
     def test_get_file_succeeds(self):
         filename = factory.make_name('file')
         factory.make_FileStorage(
+<<<<<<< TREE
             filename=filename, content=b"give me rope",
             owner=self.user)
         response = self.make_API_GET_request("get", filename)
+=======
+            filename=filename, content=b"give me rope",
+            owner=self.logged_in_user)
+        response = self.make_API_GET_request("get", filename)
+>>>>>>> MERGE-SOURCE
 
         self.assertEqual(http.client.OK, response.status_code)
         self.assertEqual(b"give me rope", response.content)
 
+<<<<<<< TREE
     def test_get_file_checks_owner(self):
         filename = factory.make_name('file')
         factory.make_FileStorage(
@@ -223,6 +234,28 @@
         self.assertEqual(http.client.OK, response.status_code)
         self.assertEqual(storage.content, response.content)
 
+=======
+    def test_get_file_checks_owner(self):
+        filename = factory.make_name('file')
+        factory.make_FileStorage(
+            filename=filename, content=b"give me rope",
+            owner=factory.make_User())
+        response = self.make_API_GET_request("get", filename)
+
+        self.assertEqual(httplib.NOT_FOUND, response.status_code)
+
+    def test_get_fetches_the_most_recent_file(self):
+        filename = factory.make_name('file')
+        factory.make_FileStorage(
+            filename=filename, owner=self.logged_in_user)
+        storage = factory.make_FileStorage(
+            filename=filename, owner=self.logged_in_user)
+        response = self.make_API_GET_request("get", filename)
+
+        self.assertEqual(httplib.OK, response.status_code)
+        self.assertEqual(storage.content, response.content)
+
+>>>>>>> MERGE-SOURCE
     def test_get_file_fails_with_no_filename(self):
         response = self.make_API_GET_request("get")
 

=== modified file 'src/maasserver/api/tests/test_interfaces.py'
--- src/maasserver/api/tests/test_interfaces.py	2016-05-26 13:28:46 +0000
+++ src/maasserver/api/tests/test_interfaces.py	2016-06-10 16:34:39 +0000
@@ -67,13 +67,22 @@
     return bond_interface, parents, [vlan_nic_10, vlan_nic_11]
 
 
+<<<<<<< TREE
 class TestInterfacesAPI(APITestCase.ForUser):
+=======
+class TestInterfacesAPI(APITestCase):
+>>>>>>> MERGE-SOURCE
 
     def test_handler_path(self):
         node = factory.make_Node()
         self.assertEqual(
+<<<<<<< TREE
             '/api/2.0/nodes/%s/interfaces/' % (node.system_id),
             get_interfaces_uri(node))
+=======
+            '/api/1.0/nodes/%s/interfaces/' % (node.system_id),
+            get_interfaces_uri(node))
+>>>>>>> MERGE-SOURCE
 
     def test_read(self):
         node = factory.make_Node()
@@ -93,6 +102,7 @@
             ]
         self.assertItemsEqual(expected_ids, result_ids)
 
+<<<<<<< TREE
     def test_read_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Device(
@@ -107,6 +117,20 @@
         self.assertEqual(
             interface.id, json_load_bytes(response.content)[0]['id'])
 
+=======
+    def test_read_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        uri = get_interfaces_uri(device)
+        response = self.client.get(uri)
+
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        self.assertEqual(interface.id, json.loads(response.content)[0]['id'])
+
+>>>>>>> MERGE-SOURCE
     def test_create_physical(self):
         self.become_admin()
         for status in (NODE_STATUS.READY, NODE_STATUS.BROKEN):
@@ -141,6 +165,7 @@
                 "enabled": Equals(True),
                 }))
 
+<<<<<<< TREE
     def test_create_physical_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Device(
@@ -175,6 +200,42 @@
             "enabled": Equals(True),
             }))
 
+=======
+    def test_create_physical_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        mac = factory.make_mac_address()
+        name = factory.make_name("eth")
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        tags = [
+            factory.make_name("tag")
+            for _ in range(3)
+        ]
+        uri = get_interfaces_uri(device)
+        response = self.client.post(uri, {
+            "op": "create_physical",
+            "mac_address": mac,
+            "name": name,
+            "vlan": vlan.id,
+            "tags": ",".join(tags),
+            })
+
+        self.assertEqual(
+            httplib.OK, response.status_code, response.content)
+        self.assertThat(json.loads(response.content), ContainsDict({
+            "mac_address": Equals(mac),
+            "name": Equals(name),
+            "vlan": ContainsDict({
+                "id": Equals(vlan.id),
+                }),
+            "type": Equals("physical"),
+            "tags": Equals(tags),
+            "enabled": Equals(True),
+            }))
+
+>>>>>>> MERGE-SOURCE
     def test_create_physical_disabled(self):
         self.become_admin()
         for status in (NODE_STATUS.READY, NODE_STATUS.BROKEN):
@@ -337,6 +398,7 @@
                 parent_2_iface.name,
                 ], parsed_interface['parents'])
 
+<<<<<<< TREE
     def test_create_bond_404_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Node(
@@ -349,6 +411,19 @@
         self.assertEqual(
             http.client.NOT_FOUND, response.status_code, response.content)
 
+=======
+    def test_create_bond_404_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        uri = get_interfaces_uri(device)
+        response = self.client.post(uri, {
+            "op": "create_bond",
+            })
+        self.assertEqual(
+            httplib.NOT_FOUND, response.status_code, response.content)
+
+>>>>>>> MERGE-SOURCE
     def test_create_bond_requires_admin(self):
         node = factory.make_Node()
         vlan = factory.make_VLAN()
@@ -417,8 +492,13 @@
         self.assertEqual({
             "mac_address": ["This field cannot be blank."],
             "name": ["This field is required."],
+<<<<<<< TREE
             "parents": ["A bond interface must have one or more parents."],
             }, json_load_bytes(response.content))
+=======
+            "parents": ["A Bond interface must have one or more parents."],
+            }, json.loads(response.content))
+>>>>>>> MERGE-SOURCE
 
     def test_create_vlan(self):
         self.become_admin()
@@ -452,6 +532,7 @@
             "tags": Equals(tags),
             }))
 
+<<<<<<< TREE
     def test_create_vlan_404_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Node(
@@ -464,6 +545,19 @@
         self.assertEqual(
             http.client.NOT_FOUND, response.status_code, response.content)
 
+=======
+    def test_create_vlan_404_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        uri = get_interfaces_uri(device)
+        response = self.client.post(uri, {
+            "op": "create_vlan",
+            })
+        self.assertEqual(
+            httplib.NOT_FOUND, response.status_code, response.content)
+
+>>>>>>> MERGE-SOURCE
     def test_create_vlan_requires_admin(self):
         node = factory.make_Node()
         untagged_vlan = factory.make_VLAN()
@@ -719,6 +813,7 @@
         parsed_interface = json_load_bytes(response.content)
         self.assertEqual(bond0.id, parsed_interface['id'])
 
+<<<<<<< TREE
     def test_read_device_interface(self):
         parent = factory.make_Node()
         device = factory.make_Device(parent=parent)
@@ -731,6 +826,19 @@
         parsed_interface = json_load_bytes(response.content)
         self.assertEqual(interface.id, parsed_interface['id'])
 
+=======
+    def test_read_device_interface(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        uri = get_interface_uri(interface)
+        response = self.client.get(uri)
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_interface = json.loads(response.content)
+        self.assertEqual(interface.id, parsed_interface['id'])
+
+>>>>>>> MERGE-SOURCE
     def test_read_404_when_invalid_id(self):
         node = factory.make_Node()
         uri = reverse(
@@ -780,6 +888,26 @@
         self.assertEquals(new_name, parsed_interface["name"])
         self.assertEquals(new_vlan.vid, parsed_interface["vlan"]["vid"])
 
+    def test_update_device_physical_interface(self):
+        node = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        new_name = factory.make_name("name")
+        new_fabric = factory.make_Fabric()
+        new_vlan = new_fabric.get_default_vlan()
+        uri = get_interface_uri(interface)
+        response = self.client.put(uri, {
+            "name": new_name,
+            "vlan": new_vlan.id,
+            })
+        self.assertEqual(
+            httplib.OK, response.status_code, response.content)
+        parsed_interface = json.loads(response.content)
+        self.assertEquals(new_name, parsed_interface["name"])
+        self.assertEquals(new_vlan.vid, parsed_interface["vlan"]["vid"])
+
     def test_update_bond_interface(self):
         self.become_admin()
         for status in (NODE_STATUS.READY, NODE_STATUS.BROKEN):
@@ -866,6 +994,7 @@
                 http.client.NO_CONTENT, response.status_code, response.content)
             self.assertIsNone(reload_object(interface))
 
+<<<<<<< TREE
     def test_delete_deletes_device_interface(self):
         parent = factory.make_Node()
         device = factory.make_Device(
@@ -878,6 +1007,20 @@
             http.client.NO_CONTENT, response.status_code, response.content)
         self.assertIsNone(reload_object(interface))
 
+=======
+    def test_delete_deletes_device_interface(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        uri = get_interface_uri(interface)
+        response = self.client.delete(uri)
+        self.assertEqual(
+            httplib.NO_CONTENT, response.status_code, response.content)
+        self.assertIsNone(reload_object(interface))
+
+>>>>>>> MERGE-SOURCE
     def test_delete_403_when_not_admin(self):
         node = factory.make_Node(interface=True)
         interface = node.get_boot_interface()
@@ -943,6 +1086,7 @@
                     "mode": Equals(INTERFACE_LINK_TYPE.DHCP),
                     }))
 
+<<<<<<< TREE
     def test_link_subnet_creates_link_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Device(
@@ -983,6 +1127,47 @@
                 http.client.BAD_REQUEST, response.status_code,
                 response.content)
 
+=======
+    def test_link_subnet_creates_link_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        uri = get_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "link_subnet",
+            "mode": INTERFACE_LINK_TYPE.STATIC,
+            "subnet": subnet.id,
+            })
+        self.assertEqual(
+            httplib.OK, response.status_code, response.content)
+        parsed_response = json.loads(response.content)
+        self.assertThat(
+            parsed_response["links"][0], ContainsDict({
+                "mode": Equals(INTERFACE_LINK_TYPE.STATIC),
+                }))
+
+    def test_link_subnet_on_device_only_allows_static(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        for link_type in [
+                INTERFACE_LINK_TYPE.AUTO,
+                INTERFACE_LINK_TYPE.DHCP,
+                INTERFACE_LINK_TYPE.LINK_UP]:
+            uri = get_interface_uri(interface)
+            response = self.client.post(uri, {
+                "op": "link_subnet",
+                "mode": link_type,
+                })
+            self.assertEqual(
+                httplib.BAD_REQUEST, response.status_code, response.content)
+
+>>>>>>> MERGE-SOURCE
     def test_link_subnet_raises_error(self):
         self.become_admin()
         for status in (NODE_STATUS.READY, NODE_STATUS.BROKEN):
@@ -1058,6 +1243,7 @@
                 http.client.OK, response.status_code, response.content)
             self.assertIsNone(reload_object(dhcp_ip))
 
+<<<<<<< TREE
     def test_unlink_subnet_deletes_link_on_device(self):
         parent = factory.make_Node()
         device = factory.make_Device(
@@ -1077,6 +1263,27 @@
             http.client.OK, response.status_code, response.content)
         self.assertIsNone(reload_object(static_ip))
 
+=======
+    def test_unlink_subnet_deletes_link_on_device(self):
+        parent = factory.make_Node()
+        device = factory.make_Node(
+            owner=self.logged_in_user, installable=False, parent=parent)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+        subnet = factory.make_Subnet()
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            subnet=subnet, interface=interface)
+        uri = get_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "unlink_subnet",
+            "id": static_ip.id,
+            })
+        self.assertEqual(
+            httplib.OK, response.status_code, response.content)
+        self.assertIsNone(reload_object(static_ip))
+
+>>>>>>> MERGE-SOURCE
     def test_unlink_subnet_raises_error(self):
         self.become_admin()
         for status in (NODE_STATUS.READY, NODE_STATUS.BROKEN):

=== added file 'src/maasserver/api/tests/test_pxeconfig.py.OTHER'
--- src/maasserver/api/tests/test_pxeconfig.py.OTHER	1970-01-01 00:00:00 +0000
+++ src/maasserver/api/tests/test_pxeconfig.py.OTHER	2016-06-10 16:34:39 +0000
@@ -0,0 +1,693 @@
+# Copyright 2013-2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for PXE configuration retrieval from the API."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+import httplib
+import json
+
+from crochet import TimeoutError
+from django.core.urlresolvers import reverse
+from django.test.client import RequestFactory
+from maasserver import (
+    preseed as preseed_module,
+    server_address,
+)
+from maasserver.api import pxeconfig as pxeconfig_module
+from maasserver.api.pxeconfig import (
+    event_log_pxe_request,
+    find_nodegroup_for_pxeconfig_request,
+    get_boot_image,
+)
+from maasserver.clusterrpc.testing.boot_images import make_rpc_boot_image
+from maasserver.enum import (
+    BOOT_RESOURCE_TYPE,
+    INTERFACE_TYPE,
+    NODE_STATUS,
+    NODEGROUPINTERFACE_MANAGEMENT,
+)
+from maasserver.models import (
+    Config,
+    Event,
+    Interface,
+    Node,
+)
+from maasserver.preseed import (
+    compose_enlistment_preseed_url,
+    compose_preseed_url,
+)
+from maasserver.testing.architecture import make_usable_architecture
+from maasserver.testing.config import RegionConfigurationFixture
+from maasserver.testing.factory import factory
+from maasserver.testing.orm import reload_object
+from maasserver.testing.testcase import MAASServerTestCase
+from maastesting.fakemethod import FakeMethod
+from maastesting.matchers import (
+    MockCalledOnceWith,
+    MockNotCalled,
+)
+from mock import sentinel
+from netaddr import IPNetwork
+from provisioningserver import kernel_opts
+from provisioningserver.kernel_opts import KernelParameters
+from provisioningserver.rpc.exceptions import NoConnectionsAvailable
+from testtools.matchers import (
+    Contains,
+    ContainsAll,
+    Equals,
+    Is,
+    MatchesListwise,
+    StartsWith,
+)
+
+
+class TestGetBootImage(MAASServerTestCase):
+
+    def test__returns_None_when_connection_unavailable(self):
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').side_effect = NoConnectionsAvailable
+        self.assertEqual(
+            None,
+            get_boot_image(
+                sentinel.nodegroup, sentinel.osystem,
+                sentinel.architecture, sentinel.subarchitecture,
+                sentinel.series, sentinel.purpose))
+
+    def test__returns_None_when_timeout_error(self):
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').side_effect = TimeoutError
+        self.assertEqual(
+            None,
+            get_boot_image(
+                sentinel.nodegroup, sentinel.osystem,
+                sentinel.architecture, sentinel.subarchitecture,
+                sentinel.series, sentinel.purpose))
+
+    def test__returns_matching_image(self):
+        subarch = factory.make_name('subarch')
+        purpose = factory.make_name('purpose')
+        boot_image = make_rpc_boot_image(
+            subarchitecture=subarch, purpose=purpose)
+        other_images = [make_rpc_boot_image() for _ in range(3)]
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').return_value = other_images + [boot_image]
+        self.assertEqual(
+            boot_image,
+            get_boot_image(
+                sentinel.nodegroup, sentinel.osystem,
+                sentinel.architecture, subarch,
+                sentinel.series, purpose))
+
+    def test__returns_None_on_no_matching_image(self):
+        subarch = factory.make_name('subarch')
+        purpose = factory.make_name('purpose')
+        other_images = [make_rpc_boot_image() for _ in range(3)]
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').return_value = other_images
+        self.assertEqual(
+            None,
+            get_boot_image(
+                sentinel.nodegroup, sentinel.osystem,
+                sentinel.architecture, subarch,
+                sentinel.series, purpose))
+
+    def test__returns_None_immediately_if_purpose_is_local(self):
+        self.patch(pxeconfig_module, 'get_boot_images_for')
+        self.expectThat(
+            get_boot_image(
+                sentinel.nodegroup, sentinel.osystem,
+                sentinel.architecture, sentinel.subarchitecture,
+                sentinel.series, "local"),
+            Is(None))
+        self.expectThat(pxeconfig_module.get_boot_images_for, MockNotCalled())
+
+
+class TestPXEConfigAPI(MAASServerTestCase):
+    def setUp(self):
+        super(TestPXEConfigAPI, self).setUp()
+        self.useFixture(RegionConfigurationFixture())
+
+    def get_default_params(self, nodegroup=None):
+        if nodegroup is None:
+            nodegroup = factory.make_NodeGroup()
+        return {
+            "local": factory.make_ipv4_address(),
+            "remote": factory.make_ipv4_address(),
+            "cluster_uuid": nodegroup.uuid,
+            }
+
+    def get_mac_params(self):
+        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
+        arch, subarch = node.split_arch()
+        image = make_rpc_boot_image(
+            osystem=node.get_osystem(), release=node.get_distro_series(),
+            architecture=arch, subarchitecture=subarch,
+            purpose='install')
+        self.patch(
+            preseed_module,
+            'get_boot_images_for').return_value = [image]
+        params = self.get_default_params()
+        params['mac'] = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node).mac_address
+        return params
+
+    def get_pxeconfig(self, params=None):
+        """Make a request to `pxeconfig`, and return its response dict."""
+        if params is None:
+            params = self.get_default_params()
+        response = self.client.get(reverse('pxeconfig'), params)
+        return json.loads(response.content)
+
+    def test_pxeconfig_returns_json(self):
+        params = self.get_default_params()
+        response = self.client.get(
+            reverse('pxeconfig'), params)
+        self.assertThat(
+            (
+                response.status_code,
+                response['Content-Type'],
+                response.content,
+                response.content,
+            ),
+            MatchesListwise(
+                (
+                    Equals(httplib.OK),
+                    Equals("application/json"),
+                    StartsWith(b'{'),
+                    Contains('arch'),
+                )),
+            response)
+
+    def test_pxeconfig_returns_all_kernel_parameters(self):
+        params = self.get_default_params()
+        self.assertThat(
+            self.get_pxeconfig(params),
+            ContainsAll(KernelParameters._fields))
+
+    def test_pxeconfig_returns_success_for_known_node(self):
+        params = self.get_mac_params()
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(httplib.OK, response.status_code)
+
+    def test_pxeconfig_returns_no_content_for_unknown_node(self):
+        params = dict(
+            mac=factory.make_mac_address(delimiter='-'),
+            local=factory.make_ipv4_address())
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(httplib.NO_CONTENT, response.status_code)
+
+    def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self):
+        architecture = make_usable_architecture(self)
+        arch, subarch = architecture.split('/')
+        nodegroup = factory.make_NodeGroup()
+        params = dict(
+            self.get_default_params(),
+            mac=factory.make_mac_address(delimiter='-'),
+            arch=arch,
+            subarch=subarch,
+            cluster_uuid=nodegroup.uuid)
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(httplib.OK, response.status_code)
+
+    def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self):
+        # An 'enlisting' node means it looks like a node with details but we
+        # don't know about it yet.  It should still receive the global
+        # kernel options.
+        value = factory.make_string()
+        Config.objects.set_config("kernel_opts", value)
+        architecture = make_usable_architecture(self)
+        arch, subarch = architecture.split('/')
+        nodegroup = factory.make_NodeGroup()
+        params = dict(
+            self.get_default_params(),
+            mac=factory.make_mac_address(delimiter='-'),
+            arch=arch,
+            subarch=subarch,
+            cluster_uuid=nodegroup.uuid)
+        response = self.client.get(reverse('pxeconfig'), params)
+        response_dict = json.loads(response.content)
+        self.assertEqual(value, response_dict['extra_opts'])
+
+    def test_pxeconfig_uses_present_boot_image(self):
+        osystem = Config.objects.get_config('commissioning_osystem')
+        release = Config.objects.get_config('commissioning_distro_series')
+        resource_name = '%s/%s' % (osystem, release)
+        factory.make_usable_boot_resource(
+            rtype=BOOT_RESOURCE_TYPE.SYNCED,
+            name=resource_name, architecture='amd64/generic')
+        params = self.get_default_params()
+        params_out = self.get_pxeconfig(params)
+        self.assertEqual("amd64", params_out["arch"])
+
+    def test_pxeconfig_defaults_to_i386_for_default(self):
+        # As a lowest-common-denominator, i386 is chosen when the node is not
+        # yet known to MAAS.
+        expected_arch = tuple(
+            make_usable_architecture(
+                self, arch_name="i386", subarch_name="generic").split("/"))
+        params = self.get_default_params()
+        params_out = self.get_pxeconfig(params)
+        observed_arch = params_out["arch"], params_out["subarch"]
+        self.assertEqual(expected_arch, observed_arch)
+
+    def test_pxeconfig_uses_fixed_hostname_for_enlisting_node(self):
+        params = self.get_default_params()
+        self.assertEqual(
+            'maas-enlist', self.get_pxeconfig(params).get('hostname'))
+
+    def test_pxeconfig_uses_nodegroup_domain_for_enlisting_node(self):
+        nodegroup = factory.make_NodeGroup()
+        params = self.get_default_params(nodegroup=nodegroup)
+        self.assertEqual(
+            nodegroup.name,
+            self.get_pxeconfig(params).get('domain'))
+
+    def test_pxeconfig_splits_domain_from_node_hostname(self):
+        host = factory.make_name('host')
+        domain = factory.make_name('domain')
+        full_hostname = '.'.join([host, domain])
+        node = factory.make_Node(hostname=full_hostname)
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        params = self.get_default_params()
+        params['mac'] = interface.mac_address
+        pxe_config = self.get_pxeconfig(params)
+        self.assertEqual(host, pxe_config.get('hostname'))
+        self.assertNotIn(domain, pxe_config.values())
+
+    def test_pxeconfig_uses_nodegroup_domain_for_node(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        params = self.get_default_params()
+        params['mac'] = interface.mac_address
+        self.assertEqual(
+            interface.node.nodegroup.name,
+            self.get_pxeconfig(params).get('domain'))
+
+    def get_without_param(self, param):
+        """Request a `pxeconfig()` response, but omit `param` from request."""
+        params = self.get_params()
+        del params[param]
+        return self.client.get(reverse('pxeconfig'), params)
+
+    def silence_get_ephemeral_name(self):
+        # Silence `get_ephemeral_name` to avoid having to fetch the
+        # ephemeral name from the filesystem.
+        self.patch(
+            kernel_opts, 'get_ephemeral_name',
+            FakeMethod(result=factory.make_string()))
+
+    def test_pxeconfig_has_enlistment_preseed_url_for_default(self):
+        self.silence_get_ephemeral_name()
+        params = self.get_default_params()
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            compose_enlistment_preseed_url(),
+            json.loads(response.content)["preseed_url"])
+
+    def test_pxeconfig_enlistment_preseed_url_detects_request_origin(self):
+        self.silence_get_ephemeral_name()
+        hostname = factory.make_hostname()
+        ng_url = 'http://%s' % hostname
+        network = IPNetwork("10.1.1/24")
+        ip = factory.pick_ip_in_network(network)
+        self.patch(server_address, 'resolve_hostname').return_value = {ip}
+        factory.make_NodeGroup(
+            maas_url=ng_url, network=network,
+            management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
+        params = self.get_default_params()
+        del params['cluster_uuid']
+
+        # Simulate that the request originates from ip by setting
+        # 'REMOTE_ADDR'.
+        response = self.client.get(
+            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
+        self.assertThat(
+            json.loads(response.content)["preseed_url"],
+            StartsWith(ng_url))
+
+    def test_pxeconfig_enlistment_log_host_url_detects_request_origin(self):
+        self.silence_get_ephemeral_name()
+        hostname = factory.make_hostname()
+        ng_url = 'http://%s' % hostname
+        network = IPNetwork("10.1.1/24")
+        ip = factory.pick_ip_in_network(network)
+        mock = self.patch(server_address, 'resolve_hostname')
+        mock.return_value = {ip}
+        factory.make_NodeGroup(
+            maas_url=ng_url, network=network,
+            management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
+        params = self.get_default_params()
+        del params['cluster_uuid']
+
+        # Simulate that the request originates from ip by setting
+        # 'REMOTE_ADDR'.
+        response = self.client.get(
+            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
+        self.assertEqual(
+            (ip, hostname),
+            (json.loads(response.content)["log_host"], mock.call_args[0][0]))
+
+    def test_pxeconfig_enlistment_checks_default_min_hwe_kernel(self):
+        params = self.get_default_params()
+        params['arch'] = 'armhf'
+        Config.objects.set_config('default_min_hwe_kernel', 'hwe-v')
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            "hwe-v",
+            json.loads(response.content)["subarch"])
+
+    def test_pxeconfig_has_preseed_url_for_known_node(self):
+        params = self.get_mac_params()
+        node = Interface.objects.get(mac_address=params['mac']).node
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            compose_preseed_url(node),
+            json.loads(response.content)["preseed_url"])
+
+    def test_find_nodegroup_for_pxeconfig_request_uses_cluster_uuid(self):
+        # find_nodegroup_for_pxeconfig_request returns the nodegroup
+        # identified by the cluster_uuid parameter, if given.  It
+        # completely ignores the other node or request details, as shown
+        # here by passing a uuid for a different cluster.
+        params = self.get_mac_params()
+        nodegroup = factory.make_NodeGroup()
+        params['cluster_uuid'] = nodegroup.uuid
+        request = RequestFactory().get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            nodegroup,
+            find_nodegroup_for_pxeconfig_request(request))
+
+    def test_preseed_url_for_known_node_uses_nodegroup_maas_url(self):
+        ng_url = 'http://%s' % factory.make_name('host')
+        network = IPNetwork("10.1.1/24")
+        ip = factory.pick_ip_in_network(network)
+        self.patch(server_address, 'resolve_hostname').return_value = {ip}
+        nodegroup = factory.make_NodeGroup(maas_url=ng_url, network=network)
+        params = self.get_mac_params()
+        node = Interface.objects.get(mac_address=params['mac']).node
+        node.nodegroup = nodegroup
+        node.save()
+
+        # Simulate that the request originates from ip by setting
+        # 'REMOTE_ADDR'.
+        response = self.client.get(
+            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
+        self.assertThat(
+            json.loads(response.content)["preseed_url"],
+            StartsWith(ng_url))
+
+    def test_pxeconfig_uses_boot_purpose_enlistment(self):
+        # test that purpose is set to "commissioning" for
+        # enlistment (when node is None).
+        params = self.get_default_params()
+        params['arch'] = 'armhf'
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            "commissioning",
+            json.loads(response.content)["purpose"])
+
+    def test_pxeconfig_returns_enlist_config_if_no_architecture_provided(self):
+        params = self.get_default_params()
+        pxe_config = self.get_pxeconfig(params)
+        self.assertEqual('enlist', pxe_config['purpose'])
+
+    def test_pxeconfig_returns_fs_host_as_cluster_controller(self):
+        # The kernel parameter `fs_host` points to the cluster controller
+        # address, which is passed over within the `local` parameter.
+        params = self.get_default_params()
+        kernel_params = KernelParameters(**self.get_pxeconfig(params))
+        self.assertEqual(params["local"], kernel_params.fs_host)
+
+    def test_pxeconfig_returns_extra_kernel_options(self):
+        extra_kernel_opts = factory.make_string()
+        Config.objects.set_config('kernel_opts', extra_kernel_opts)
+        params = self.get_mac_params()
+        pxe_config = self.get_pxeconfig(params)
+        self.assertEqual(extra_kernel_opts, pxe_config['extra_opts'])
+
+    def test_pxeconfig_returns_None_for_extra_kernel_opts(self):
+        params = self.get_mac_params()
+        pxe_config = self.get_pxeconfig(params)
+        self.assertEqual(None, pxe_config['extra_opts'])
+
+    def test_pxeconfig_returns_commissioning_for_insane_state(self):
+        nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        pxe_config = self.get_pxeconfig(params)
+        # The 'purpose' of the PXE config is 'commissioning' here
+        # even if the 'purpose' returned by node.get_boot_purpose
+        # is 'poweroff' because MAAS needs to bring the machine
+        # up in a commissioning environment in order to power
+        # the machine down.
+        self.assertEqual('commissioning', pxe_config['purpose'])
+
+    def test_pxeconfig_returns_commissioning_for_ready_node(self):
+        nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nic.node.status = NODE_STATUS.READY
+        nic.node.save()
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        pxe_config = self.get_pxeconfig(params)
+        self.assertEqual('commissioning', pxe_config['purpose'])
+
+    def test_pxeconfig_returns_image_subarch_not_node_subarch(self):
+        # In the scenario such as deploying trusty on an hwe-s subarch
+        # node, the code will have fallen back to using trusty's generic
+        # image as per the supported_subarches on the image. However,
+        # pxeconfig needs to make sure the image path refers to the
+        # subarch from the image, rather than the requested one.
+        osystem = 'ubuntu'
+        release = Config.objects.get_config('default_distro_series')
+        nodegroup = factory.make_NodeGroup()
+        generic_image = make_rpc_boot_image(
+            osystem=osystem, release=release,
+            architecture="amd64", subarchitecture="generic",
+            purpose='install')
+        hwe_s_image = make_rpc_boot_image(
+            osystem=osystem, release=release,
+            architecture="amd64", subarchitecture="hwe-s",
+            purpose='install')
+        self.patch(
+            preseed_module,
+            'get_boot_images_for').return_value = [generic_image, hwe_s_image]
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').return_value = [generic_image, hwe_s_image]
+        node = factory.make_Node(
+            interface=True, nodegroup=nodegroup, status=NODE_STATUS.DEPLOYING,
+            architecture="amd64/hwe-s")
+        params = self.get_default_params()
+        params['cluster_uuid'] = nodegroup.uuid
+        params['mac'] = node.get_boot_interface().mac_address
+        params['arch'] = "amd64"
+        params['subarch'] = "hwe-s"
+
+        params_out = self.get_pxeconfig(params)
+        self.assertEqual("hwe-s", params_out["subarch"])
+
+    def test_pxeconfig_calls_event_log_pxe_request(self):
+        node = factory.make_Node()
+        nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        event_log_pxe_request = self.patch_autospec(
+            pxeconfig_module, 'event_log_pxe_request')
+        self.client.get(reverse('pxeconfig'), params)
+        self.assertThat(
+            event_log_pxe_request,
+            MockCalledOnceWith(node, node.get_boot_purpose()))
+
+    def test_event_log_pxe_request_for_known_boot_purpose(self):
+        purposes = [
+            ("commissioning", "commissioning"),
+            ("install", "d-i install"),
+            ("xinstall", "curtin install"),
+            ("local", "local boot"),
+            ("poweroff", "power off")]
+        for purpose, description in purposes:
+            node = factory.make_Node()
+            event_log_pxe_request(node, purpose)
+            self.assertEqual(
+                description,
+                Event.objects.get(node=node).description)
+
+    def test_pxeconfig_sets_boot_interface_when_empty(self):
+        node = factory.make_Node(interface=True)
+        nic = node.get_boot_interface()
+        node.boot_interface = None
+        node.save()
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        self.client.get(reverse('pxeconfig'), params)
+        node = reload_object(node)
+        self.assertEqual(nic, node.boot_interface)
+
+    def test_pxeconfig_updates_boot_interface_when_changed(self):
+        node = factory.make_Node(interface=True)
+        node.boot_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        node.save()
+        nic = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        self.client.get(reverse('pxeconfig'), params)
+        node = reload_object(node)
+        self.assertEqual(nic, node.boot_interface)
+
+    def test_pxeconfig_doesnt_update_boot_interface_when_same(self):
+        node = factory.make_Node()
+        node.boot_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        params = self.get_default_params()
+        params['mac'] = node.boot_interface.mac_address
+        node.boot_cluster_ip = params['local']
+        node.save()
+        mock_save = self.patch(Node, 'save')
+        self.client.get(reverse('pxeconfig'), params)
+        self.assertThat(mock_save, MockNotCalled())
+
+    def test_pxeconfig_sets_boot_cluster_ip_when_empty(self):
+        node = factory.make_Node(interface=True)
+        params = self.get_default_params()
+        params['mac'] = node.get_boot_interface().mac_address
+        self.client.get(reverse('pxeconfig'), params)
+        node = reload_object(node)
+        self.assertEqual(params['local'], node.boot_cluster_ip)
+
+    def test_pxeconfig_updates_boot_cluster_ip_when_changed(self):
+        node = factory.make_Node(interface=True)
+        node.boot_cluster_ip = factory.make_ipv4_address()
+        node.save()
+        params = self.get_default_params()
+        params['mac'] = node.get_boot_interface().mac_address
+        self.client.get(reverse('pxeconfig'), params)
+        node = reload_object(node)
+        self.assertEqual(params['local'], node.boot_cluster_ip)
+
+    def test_pxeconfig_doesnt_update_boot_cluster_ip_when_same(self):
+        node = factory.make_Node()
+        node.boot_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        params = self.get_default_params()
+        params['mac'] = node.boot_interface.mac_address
+        node.boot_cluster_ip = params['local']
+        node.save()
+        mock_save = self.patch(Node, 'save')
+        self.client.get(reverse('pxeconfig'), params)
+        self.assertThat(mock_save, MockNotCalled())
+
+    def test_pxeconfig_updates_bios_boot_method(self):
+        node = factory.make_Node(interface=True)
+        nic = node.get_boot_interface()
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        params['bios_boot_method'] = 'pxe'
+        self.client.get(reverse('pxeconfig'), params)
+        node = reload_object(node)
+        self.assertEqual('pxe', node.bios_boot_method)
+
+    def test_pxeconfig_doesnt_update_bios_boot_method_when_same(self):
+        node = factory.make_Node(interface=True, bios_boot_method='uefi')
+        nic = node.get_boot_interface()
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        params['bios_boot_method'] = 'uefi'
+        node.boot_interface = nic
+        node.boot_cluster_ip = params['local']
+        node.save()
+        mock_save = self.patch(Node, 'save')
+        self.client.get(reverse('pxeconfig'), params)
+        self.assertThat(mock_save, MockNotCalled())
+
+    def test_pxeconfig_returns_commissioning_os_series_for_other_oses(self):
+        osystem = Config.objects.get_config('default_osystem')
+        release = Config.objects.get_config('commissioning_distro_series')
+        nodegroup = factory.make_NodeGroup()
+        os_image = make_rpc_boot_image(purpose='xinstall')
+        architecture = '%s/%s' % (
+            os_image['architecture'], os_image['subarchitecture'])
+        self.patch(
+            preseed_module,
+            'get_boot_images_for').return_value = [os_image]
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').return_value = [os_image]
+        node = factory.make_Node(
+            interface=True, nodegroup=nodegroup, status=NODE_STATUS.DEPLOYING,
+            osystem=os_image['osystem'],
+            distro_series=os_image['release'],
+            architecture=architecture)
+        params = self.get_default_params()
+        params['cluster_uuid'] = nodegroup.uuid
+        params['mac'] = node.get_boot_interface().mac_address
+        params_out = self.get_pxeconfig(params)
+        self.assertEqual(osystem, params_out["osystem"])
+        self.assertEqual(release, params_out["release"])
+
+    def test_pxeconfig_commissioning_node_uses_min_hwe_kernel(self):
+        node = factory.make_Node(min_hwe_kernel="hwe-v")
+        nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        self.patch(Node, 'get_boot_purpose').return_value = "commissioning"
+        params = self.get_default_params()
+        params['mac'] = nic.mac_address
+        response = self.client.get(reverse('pxeconfig'), params)
+        self.assertEqual(
+            "hwe-v",
+            json.loads(response.content)["subarch"])
+
+    def test_pxeconfig_returns_ubuntu_os_series_for_ubuntu_xinstall(self):
+        nodegroup = factory.make_NodeGroup()
+        ubuntu_image = make_rpc_boot_image(
+            osystem='ubuntu', purpose='xinstall')
+        architecture = '%s/%s' % (
+            ubuntu_image['architecture'], ubuntu_image['subarchitecture'])
+        self.patch(
+            preseed_module,
+            'get_boot_images_for').return_value = [ubuntu_image]
+        self.patch(
+            pxeconfig_module,
+            'get_boot_images_for').return_value = [ubuntu_image]
+        node = factory.make_Node(
+            interface=True, nodegroup=nodegroup, status=NODE_STATUS.DEPLOYING,
+            osystem='ubuntu', distro_series=ubuntu_image['release'],
+            architecture=architecture)
+        params = self.get_default_params()
+        params['cluster_uuid'] = nodegroup.uuid
+        params['mac'] = node.get_boot_interface().mac_address
+        params_out = self.get_pxeconfig(params)
+        self.assertEqual(ubuntu_image['release'], params_out["release"])
+
+    def test_pxeconfig_returns_commissioning_os_when_erasing_disks(self):
+        commissioning_osystem = factory.make_name("os")
+        Config.objects.set_config(
+            "commissioning_osystem", commissioning_osystem)
+        commissioning_series = factory.make_name("series")
+        Config.objects.set_config(
+            "commissioning_distro_series", commissioning_series)
+        nodegroup = factory.make_NodeGroup()
+        node = factory.make_Node(
+            nodegroup=nodegroup, status=NODE_STATUS.DISK_ERASING,
+            osystem=factory.make_name("centos"), interface=True,
+            distro_series=factory.make_name("release"))
+        params = self.get_default_params()
+        params['cluster_uuid'] = nodegroup.uuid
+        params['mac'] = node.get_boot_interface().mac_address
+        params_out = self.get_pxeconfig(params)
+        self.assertEqual(commissioning_osystem, params_out['osystem'])
+        self.assertEqual(commissioning_series, params_out['release'])

=== modified file 'src/maasserver/api/tests/test_raid.py'
=== modified file 'src/maasserver/api/tests/test_support.py'
--- src/maasserver/api/tests/test_support.py	2016-05-24 21:29:53 +0000
+++ src/maasserver/api/tests/test_support.py	2016-06-10 16:34:39 +0000
@@ -37,6 +37,7 @@
     Equals,
     Is,
 )
+<<<<<<< TREE
 
 
 class StubHandler:
@@ -46,6 +47,22 @@
 
 
 class TestOperationsResource(APITestCase.ForUser):
+=======
+from piston.authentication import NoAuthentication
+from testtools.matchers import (
+    Equals,
+    Is,
+)
+
+
+class StubHandler:
+    """A stub handler class that breaks when called."""
+    def __call__(self, request):
+        raise AssertionError("Do not call the stub handler.")
+
+
+class TestOperationsResource(APITestCase):
+>>>>>>> MERGE-SOURCE
 
     def test_type_error_is_not_hidden(self):
         # This tests that bug #1228205 is fixed (i.e. that a
@@ -81,6 +98,7 @@
             response["X-MAAS-API-Hash"],
             Equals(get_api_description_hash()))
 
+<<<<<<< TREE
     def test_authenticated_is_False_when_no_authentication_provided(self):
         resource = OperationsResource(StubHandler)
         self.assertThat(resource.is_authentication_attempted, Is(False))
@@ -136,6 +154,63 @@
 
 
 class TestAdminMethodDecorator(MAASServerTestCase):
+=======
+    def test_authenticated_is_False_when_no_authentication_provided(self):
+        resource = OperationsResource(StubHandler)
+        self.assertThat(resource.is_authentication_attempted, Is(False))
+
+    def test_authenticated_is_False_when_authentication_is_empty(self):
+        resource = OperationsResource(StubHandler, authentication=[])
+        self.assertThat(resource.is_authentication_attempted, Is(False))
+
+    def test_authenticated_is_False_when_authentication_is_NoAuthn(self):
+        resource = OperationsResource(
+            StubHandler, authentication=NoAuthentication())
+        self.assertThat(resource.is_authentication_attempted, Is(False))
+
+    def test_authenticated_is_True_when_authentication_is_provided(self):
+        resource = OperationsResource(
+            StubHandler, authentication=sentinel.authentication)
+        self.assertThat(resource.is_authentication_attempted, Is(True))
+
+
+class TestRestrictedResources(APITestCase):
+    """Tests for `RestrictedResource` and `AdminRestrictedResource`."""
+
+    scenarios = (
+        ("user", dict(resource_type=RestrictedResource)),
+        ("admin", dict(resource_type=AdminRestrictedResource)),
+    )
+
+    def test_authentication_must_not_be_None(self):
+        error = self.assertRaises(
+            AssertionError, self.resource_type, StubHandler,
+            authentication=None)
+        self.assertThat(unicode(error), Equals(
+            "Authentication must be attempted."))
+
+    def test_authentication_must_be_non_empty(self):
+        error = self.assertRaises(
+            AssertionError, self.resource_type, StubHandler,
+            authentication=[])
+        self.assertThat(unicode(error), Equals(
+            "Authentication must be attempted."))
+
+    def test_authentication_must_be_meaningful(self):
+        error = self.assertRaises(
+            AssertionError, self.resource_type, StubHandler,
+            authentication=NoAuthentication())
+        self.assertThat(unicode(error), Equals(
+            "Authentication must be attempted."))
+
+    def test_authentication_is_okay(self):
+        resource = self.resource_type(
+            StubHandler, authentication=sentinel.authentication)
+        self.assertThat(resource.is_authentication_attempted, Is(True))
+
+
+class TestAdminMethodDecorator(APITestCase):
+>>>>>>> MERGE-SOURCE
 
     def test_non_admin_are_rejected(self):
         FakeRequest = namedtuple('FakeRequest', ['user'])

=== modified file 'src/maasserver/api/tests/test_version.py'
--- src/maasserver/api/tests/test_version.py	2016-05-24 14:43:27 +0000
+++ src/maasserver/api/tests/test_version.py	2016-06-10 16:34:39 +0000
@@ -9,13 +9,24 @@
 import http.client
 import json
 
+<<<<<<< TREE
 from django.conf import settings
+=======
+from django.contrib.auth.models import AnonymousUser
+>>>>>>> MERGE-SOURCE
 from django.core.urlresolvers import reverse
 from maasserver.api.version import API_CAPABILITIES_LIST
+<<<<<<< TREE
 from maasserver.testing.api import APITestCase
+=======
+from maasserver.testing.api import MultipleUsersScenarios
+from maasserver.testing.factory import factory
+from maasserver.testing.testcase import MAASServerTestCase
+>>>>>>> MERGE-SOURCE
 from maasserver.utils import version as version_module
 
 
+<<<<<<< TREE
 class TestVersionAPIBasics(APITestCase.ForAnonymousAndUserAndAdmin):
     """Basic tests for /version/ API."""
 
@@ -26,7 +37,27 @@
 
 class TestVersionAPI(APITestCase.ForAnonymousAndUser):
     """Tests for /version/ API."""
-
+=======
+class TestVersionAPIBasics(MAASServerTestCase):
+    """Basic tests for /version/ API."""
+>>>>>>> MERGE-SOURCE
+
+<<<<<<< TREE
+=======
+    def test_handler_path(self):
+        self.assertEqual(
+            '/api/1.0/version/', reverse('version_handler'))
+
+
+class TestVersionAPI(MultipleUsersScenarios, MAASServerTestCase):
+    """Tests for /version/ API."""
+
+    scenarios = [
+        ('anon', dict(userfactory=AnonymousUser)),
+        ('user', dict(userfactory=factory.make_User)),
+    ]
+
+>>>>>>> MERGE-SOURCE
     def test_GET_returns_details(self):
         mock_apt = self.patch(version_module, "get_version_from_apt")
         mock_apt.return_value = "1.8.0~alpha4+bzr356-0ubuntu1"

=== 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-06-10 16:34:39 +0000
@@ -76,6 +76,7 @@
             "vid": vid,
             "mtu": mtu,
         })
+<<<<<<< TREE
         self.assertEqual(
             http.client.OK, response.status_code, response.content)
         response_data = json.loads(
@@ -83,6 +84,12 @@
         self.assertEqual(vlan_name, response_data['name'])
         self.assertEqual(vid, response_data['vid'])
         self.assertEqual(mtu, response_data['mtu'])
+=======
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        self.assertEqual(vlan_name, json.loads(response.content)['name'])
+        self.assertEqual(vid, json.loads(response.content)['vid'])
+        self.assertEqual(mtu, json.loads(response.content)['mtu'])
+>>>>>>> MERGE-SOURCE
 
     def test_create_admin_only(self):
         fabric = factory.make_Fabric()

=== modified file 'src/maasserver/api/tests/test_volume_groups.py'
--- src/maasserver/api/tests/test_volume_groups.py	2016-05-24 21:29:53 +0000
+++ src/maasserver/api/tests/test_volume_groups.py	2016-06-10 16:34:39 +0000
@@ -25,11 +25,19 @@
 from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
 from maasserver.testing.api import APITestCase
 from maasserver.testing.factory import factory
+<<<<<<< TREE
 from maasserver.utils.converters import (
     human_readable_bytes,
     round_size_to_nearest_block,
 )
 from maasserver.utils.orm import reload_object
+=======
+from maasserver.testing.orm import reload_object
+from maasserver.utils.converters import (
+    human_readable_bytes,
+    round_size_to_nearest_block,
+)
+>>>>>>> MERGE-SOURCE
 from testtools.matchers import (
     ContainsDict,
     Equals,
@@ -416,12 +424,19 @@
             "uuid": vguuid,
             "size": size,
             })
+<<<<<<< TREE
         self.assertEqual(
             http.client.OK, response.status_code, response.content)
         logical_volume = json.loads(
             response.content.decode(settings.DEFAULT_CHARSET))
         expected_size = round_size_to_nearest_block(
             size, PARTITION_ALIGNMENT_SIZE, False)
+=======
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        logical_volume = json.loads(response.content)
+        expected_size = round_size_to_nearest_block(
+            size, PARTITION_ALIGNMENT_SIZE, False)
+>>>>>>> MERGE-SOURCE
         self.assertThat(logical_volume, ContainsDict({
             "name": Equals("%s-%s" % (volume_group.name, name)),
             "uuid": Equals(vguuid),

=== 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-06-10 16:34:39 +0000
@@ -21,11 +21,15 @@
     'name',
     'vid',
     'fabric',
+<<<<<<< TREE
     'mtu',
     'primary_rack',
     'secondary_rack',
     'dhcp_on',
     'external_dhcp',
+=======
+    'mtu',
+>>>>>>> MERGE-SOURCE
 )
 
 
@@ -162,6 +166,7 @@
         :param description: Description of the VLAN.
         :type description: unicode
         :param vid: VLAN ID of the VLAN.
+<<<<<<< TREE
         :type vid: integer
         :param mtu: The MTU to use on the VLAN.
         :type mtu: integer
@@ -171,6 +176,11 @@
         :type primary_rack: system_id
         :param secondary_rack: The secondary rack controller manging the VLAN.
         :type secondary_rack: system_id
+=======
+        :type vid: integer
+        :param mtu: The MTU to use on the VLAN.
+        :type mtu: integer
+>>>>>>> MERGE-SOURCE
 
         Returns 404 if the fabric or VLAN is not found.
         """

=== modified file 'src/maasserver/dns/tests/test_config.py'
=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2016-05-17 20:28:10 +0000
+++ src/maasserver/forms.py	2016-06-10 16:34:39 +0000
@@ -120,7 +120,20 @@
     Zone,
 )
 from maasserver.models.blockdevice import MIN_BLOCK_DEVICE_SIZE
-from maasserver.models.partition import MIN_PARTITION_SIZE
+<<<<<<< TREE
+from maasserver.models.partition import MIN_PARTITION_SIZE
+=======
+from maasserver.models.node import (
+    fqdn_is_duplicate,
+    nodegroup_fqdn,
+)
+from maasserver.models.nodegroup import NODEGROUP_CLUSTER_NAME_TEMPLATE
+from maasserver.models.partition import MIN_PARTITION_SIZE
+from maasserver.models.subnet import (
+    create_cidr,
+    Subnet,
+)
+>>>>>>> MERGE-SOURCE
 from maasserver.node_action import (
     ACTION_CLASSES,
     ACTIONS_DICT,

=== modified file 'src/maasserver/forms_interface.py'
--- src/maasserver/forms_interface.py	2016-04-22 17:28:15 +0000
+++ src/maasserver/forms_interface.py	2016-06-10 16:34:39 +0000
@@ -213,6 +213,18 @@
                     "untagged VLAN.")
         return new_vlan
 
+    def clean_vlan(self):
+        new_vlan = self.cleaned_data.get('vlan')
+        if new_vlan and new_vlan.fabric.get_default_vlan() != new_vlan:
+            # A device's physical interface can be connected to a tagged VLAN.
+            # This is because a container or VM could be bridged on the machine
+            # to a tagged VLAN interface. See lp:1572070 for details.
+            if self.node.installable:
+                raise ValidationError(
+                    "A physical interface can only belong to an "
+                    "untagged VLAN.")
+        return new_vlan
+
     def clean(self):
         cleaned_data = super(PhysicalInterfaceForm, self).clean()
         new_name = cleaned_data.get('name')
@@ -399,6 +411,33 @@
             'name',
         )
 
+<<<<<<< TREE
+    def clean_vlan(self):
+        new_vlan = self.cleaned_data.get('vlan')
+        if new_vlan and new_vlan.fabric.get_default_vlan() != new_vlan:
+            raise ValidationError(
+                "A bond interface can only belong to an untagged VLAN.")
+        return new_vlan
+=======
+    def __init__(self, *args, **kwargs):
+        super(BondInterfaceForm, self).__init__(*args, **kwargs)
+        # Allow VLAN to be blank when creating.
+        instance = kwargs.get("instance", None)
+        if instance is not None and instance.id is not None:
+            self.fields['vlan'].required = True
+        else:
+            self.fields['vlan'].required = False
+
+    def clean_parents(self):
+        parents = self.get_clean_parents()
+        if parents is None:
+            return
+        if len(parents) < 1:
+            msg = "A Bond interface must have one or more parents."
+            raise ValidationError({'parents': [msg]})
+        return parents
+>>>>>>> MERGE-SOURCE
+
     def clean_vlan(self):
         new_vlan = self.cleaned_data.get('vlan')
         if new_vlan and new_vlan.fabric.get_default_vlan() != new_vlan:
@@ -407,8 +446,13 @@
         return new_vlan
 
     def clean(self):
+<<<<<<< TREE
         cleaned_data = super().clean()
         if self.fields_ok(['vlan', 'parents']):
+=======
+        cleaned_data = super(BondInterfaceForm, self).clean()
+        if self.fields_ok(['vlan', 'parents']):
+>>>>>>> MERGE-SOURCE
             parents = self.cleaned_data.get('parents')
             # Set the mac_address if its missing and the interface is being
             # created.
@@ -428,10 +472,36 @@
                 parent.vlan
                 for parent in parents
                 }
+<<<<<<< TREE
             if parent_vlans != set([vlan]):
                 set_form_error(
                     self, 'parents',
                     "All parents must belong to the same VLAN.")
+=======
+                if parents_with_other_children:
+                    set_form_error(
+                        self, 'parents',
+                        "%s is already in-use by another interface." % (
+                            ', '.join(sorted(parents_with_other_children))))
+
+                # When creating the bond set VLAN to the same as the parents
+                # and check that the parents all belong to the same VLAN.
+                if self.instance.id is None:
+                    vlan = self.cleaned_data.get('vlan')
+                    if vlan is None:
+                        vlan = parents[0].vlan
+                        self.cleaned_data['vlan'] = vlan
+                    parent_vlans = {
+                        parent.vlan
+                        for parent in parents
+                    }
+                    if parent_vlans != set([vlan]):
+                        set_form_error(
+                            self, 'parents',
+                            "All parents must belong to the same VLAN.")
+
+        return cleaned_data
+>>>>>>> MERGE-SOURCE
 
     def set_extra_parameters(self, interface, created):
         """Set the bond parameters as well."""
@@ -454,6 +524,7 @@
             elif created:
                 interface.params[bond_field] = self.fields[bond_field].initial
 
+<<<<<<< TREE
 
 class BridgeInterfaceForm(ChildInterfaceForm):
     """Form used to create/edit a bridge interface."""
@@ -476,6 +547,8 @@
                 self._validate_parental_fidelity(parents)
                 self._set_default_vlan(parents)
         return cleaned_data
+=======
+>>>>>>> MERGE-SOURCE
 
 INTERFACE_FORM_MAPPING = {
     INTERFACE_TYPE.PHYSICAL: PhysicalInterfaceForm,

=== modified file 'src/maasserver/forms_interface_link.py'
=== modified file 'src/maasserver/forms_subnet.py'
--- src/maasserver/forms_subnet.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/forms_subnet.py	2016-06-10 16:34:39 +0000
@@ -8,8 +8,12 @@
 ]
 
 from django import forms
+<<<<<<< TREE
 from maasserver.enum import RDNS_MODE_CHOICES
 from maasserver.fields import IPListFormField
+=======
+from maasserver.fields import IPListFormField
+>>>>>>> MERGE-SOURCE
 from maasserver.forms import MAASModelForm
 from maasserver.models.fabric import Fabric
 from maasserver.models.space import Space
@@ -60,12 +64,19 @@
 
     def clean(self):
         cleaned_data = super(SubnetForm, self).clean()
+<<<<<<< TREE
         # The default value for allow_proxy is True.
         if 'allow_proxy' not in self.data:
             cleaned_data['allow_proxy'] = 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')
+=======
+        # The djorm_pgarray.fields.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')
+>>>>>>> MERGE-SOURCE
         cleaned_data = self._clean_name(cleaned_data)
         cleaned_data = self._clean_dns_servers(cleaned_data)
         if self.instance.id is None:
@@ -133,6 +144,7 @@
         if space is None:
             cleaned_data["space"] = Space.objects.get_default_space()
         return cleaned_data
+<<<<<<< TREE
 
     def _clean_dns_servers(self, cleaned_data):
         dns_servers = cleaned_data.get("dns_servers", None)
@@ -146,3 +158,17 @@
                 clean_dns_servers += ip_list_cleaned.split(" ")
         cleaned_data["dns_servers"] = clean_dns_servers
         return cleaned_data
+=======
+
+    def _clean_dns_servers(self, cleaned_data):
+        dns_servers = cleaned_data.get("dns_servers", None)
+        if dns_servers is None:
+            return cleaned_data
+        clean_dns_servers = []
+        for dns_server in dns_servers:
+            ip_list_form = IPListFormField()
+            ip_list_cleaned = ip_list_form.clean(dns_server)
+            clean_dns_servers += ip_list_cleaned.split(" ")
+        cleaned_data["dns_servers"] = clean_dns_servers
+        return cleaned_data
+>>>>>>> MERGE-SOURCE

=== 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-06-10 16:34:39 +0000
@@ -8,8 +8,11 @@
 ]
 
 from django import forms
+<<<<<<< TREE
 from django.core.exceptions import ValidationError
 from maasserver.fields import NodeChoiceField
+=======
+>>>>>>> MERGE-SOURCE
 from maasserver.forms import MAASModelForm
 from maasserver.models import RackController
 from maasserver.models.vlan import VLAN
@@ -63,6 +66,7 @@
 
     def clean(self):
         cleaned_data = super(VLANForm, self).clean()
+<<<<<<< TREE
         # Automatically promote the secondary rack controller to the primary
         # if the primary is removed.
         if (not cleaned_data.get('primary_rack') and
@@ -103,6 +107,8 @@
         if (cleaned_data.get('secondary_rack') is None and
                 self.instance.secondary_rack is not None):
             self.instance.secondary_rack = None
+=======
+>>>>>>> MERGE-SOURCE
         return cleaned_data
 
     def clean_dhcp_on(self):

=== modified file 'src/maasserver/management/commands/_config.py'
=== modified file 'src/maasserver/management/commands/tests/test_config.py'
=== modified file 'src/maasserver/middleware.py'
=== modified file 'src/maasserver/migrations/south/migrations/0181_initial_storage_layouts.py'
=== modified file 'src/maasserver/migrations/south/migrations/0182_initial_networking_layout.py'
=== modified file 'src/maasserver/migrations/south/migrations/0188_dli_power_driver_system_id_to_outlet_id.py'
=== modified file 'src/maasserver/models/__init__.py'
--- src/maasserver/models/__init__.py	2016-04-21 16:32:47 +0000
+++ src/maasserver/models/__init__.py	2016-06-10 16:34:39 +0000
@@ -256,6 +256,7 @@
                 raise NotImplementedError(
                     'Invalid permission check (invalid permission name: %s).' %
                     perm)
+<<<<<<< TREE
         elif isinstance(obj, Interface):
             if perm == NODE_PERMISSION.VIEW:
                 # Any registered user can view a interface regardless
@@ -287,6 +288,28 @@
                     'Invalid permission check (invalid permission name: %s).' %
                     perm)
         elif isinstance(obj, (Fabric, FanNetwork, Subnet, Space, VLAN)):
+=======
+        elif isinstance(obj, Interface):
+            if perm == NODE_PERMISSION.VIEW:
+                # Any registered user can view a interface regardless
+                # of its state.
+                return True
+            elif perm in NODE_PERMISSION.EDIT:
+                # A device can be editted by its owner a node must be admin.
+                node = obj.get_node()
+                if node is None or node.installable:
+                    return user.is_superuser
+                else:
+                    return node.owner == user
+            elif perm in NODE_PERMISSION.ADMIN:
+                # Admin permission is solely granted to superusers.
+                return user.is_superuser
+            else:
+                raise NotImplementedError(
+                    'Invalid permission check (invalid permission name: %s).' %
+                    perm)
+        elif isinstance(obj, (Fabric, FanNetwork, Subnet, Space)):
+>>>>>>> MERGE-SOURCE
             if perm == NODE_PERMISSION.VIEW:
                 # Any registered user can view a fabric or interface regardless
                 # of its state.

=== modified file 'src/maasserver/models/blockdevice.py'
=== modified file 'src/maasserver/models/config.py'
=== modified file 'src/maasserver/models/fabric.py'
--- src/maasserver/models/fabric.py	2016-04-27 20:18:20 +0000
+++ src/maasserver/models/fabric.py	2016-06-10 16:34:39 +0000
@@ -164,8 +164,13 @@
 
     objects = FabricManager()
 
+<<<<<<< TREE
     # We don't actually allow blank or null name, but that is enforced in
     # clean() and save().
+=======
+    # We don't actually allow blank or null name, but that is enforced in
+    # clean() and save().  Ditto for unique.
+>>>>>>> MERGE-SOURCE
     name = CharField(
         max_length=256, editable=True, null=True, blank=True, unique=True,
         validators=[validate_fabric_name])
@@ -224,6 +229,7 @@
         # Name will get set by clean_name() if None or empty, and there is an
         # id. We just need to handle names here for creation.
         created = self.id is None
+<<<<<<< TREE
         super().save(*args, **kwargs)
         if self.name is None or self.name == '':
             # If we got here, then we have a newly created fabric that needs a
@@ -231,21 +237,46 @@
             self.name = "fabric-%d" % self.id
             fabric = Fabric.objects.get(id=self.id)
             fabric.save()
+=======
+        super(Fabric, self).save(*args, **kwargs)
+        if self.name is None or self.name == '':
+            # If we got here, then we have a newly created fabric that needs a
+            # default name.
+            self.name = "fabric-%d" % self.id
+            fabric = Fabric.objects.get(id=self.id)
+            fabric.save()
+>>>>>>> MERGE-SOURCE
         # Create default VLAN if this is a fabric creation.
         if created:
             self._create_default_vlan()
 
     def clean_name(self):
-        reserved = re.compile('^fabric-\d+$')
-        if self.name is not None and self.name != '':
-            if reserved.search(self.name):
-                if (self.id is None or self.name != 'fabric-%d' % self.id):
-                    raise ValidationError(
-                        {'name': ["Reserved fabric name."]})
-        elif self.id is not None:
-            # Since we are not creating the fabric, force the (null or empty)
-            # name to be the default name.
-            self.name = "fabric-%d" % self.id
+<<<<<<< TREE
+        reserved = re.compile('^fabric-\d+$')
+        if self.name is not None and self.name != '':
+            if reserved.search(self.name):
+                if (self.id is None or self.name != 'fabric-%d' % self.id):
+                    raise ValidationError(
+                        {'name': ["Reserved fabric name."]})
+        elif self.id is not None:
+            # Since we are not creating the fabric, force the (null or empty)
+            # name to be the default name.
+            self.name = "fabric-%d" % self.id
+=======
+        reserved = re.compile('^fabric-\d+$')
+        if self.name is not None and self.name != '':
+            if reserved.search(self.name):
+                if (self.id is None or self.name != 'fabric-%d' % self.id):
+                    raise ValidationError(
+                        {'name': ["Reserved fabric name."]})
+        elif self.id is not None:
+            # Since we are not creating the fabric, force the (null or empty)
+            # name to be the default name.
+            self.name = "fabric-%d" % self.id
+        name_count = Fabric.objects.filter(name=self.name).count()
+        if name_count > 0 + (self.id is not None):
+            raise ValidationError("Duplicate name: %s" % self.name)
+>>>>>>> MERGE-SOURCE
 
     def clean(self, *args, **kwargs):
         super().clean(*args, **kwargs)

=== modified file 'src/maasserver/models/filestorage.py'
=== modified file 'src/maasserver/models/filesystemgroup.py'
=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/models/interface.py	2016-06-10 16:34:39 +0000
@@ -36,6 +36,7 @@
     IPADDRESS_TYPE,
 )
 from maasserver.exceptions import (
+    StaticIPAddressExhaustion,
     StaticIPAddressOutOfRange,
     StaticIPAddressUnavailable,
 )
@@ -420,6 +421,7 @@
     def get_node(self):
         return self.node
 
+<<<<<<< TREE
     def get_log_string(self):
         hostname = "<unknown-node>"
         node = self.get_node()
@@ -427,6 +429,15 @@
             hostname = node.hostname
         return "%s (%s) on %s" % (self.get_name(), self.type, hostname)
 
+=======
+    def get_log_string(self):
+        hostname = "<unknown-node>"
+        node = self.get_node()
+        if node is not None:
+            hostname = node.hostname
+        return "%s on %s" % (self.get_name(), hostname)
+
+>>>>>>> MERGE-SOURCE
     def get_name(self):
         return self.name
 
@@ -748,11 +759,24 @@
         the same VLAN as the interface. If no subnet could be identified then
         its just set to DHCP.
         """
+<<<<<<< TREE
         # XXX mpontillo 2015-11-29: since we tend to dump a large number of
         # subnets into the default VLAN, this assumption might be incorrect in
         # many cases, leading to interfaces being configured as AUTO when
         # they should be configured as DHCP.
         found_subnet = self.vlan.subnet_set.first()
+=======
+        found_subnet = None
+        # XXX mpontillo 2015-11-29: since we tend to dump a large number of
+        # subnets into the default VLAN, this assumption might be incorrect in
+        # many cases, leading to interfaces being configured as AUTO when
+        # they should be configured as DHCP.
+        for subnet in self.vlan.subnet_set.all():
+            ngi = subnet.get_managed_cluster_interface()
+            if ngi is not None:
+                found_subnet = subnet
+                break
+>>>>>>> MERGE-SOURCE
         if found_subnet is not None:
             return self.link_subnet(INTERFACE_LINK_TYPE.AUTO, found_subnet)
         else:
@@ -890,16 +914,36 @@
         for auto_ip in self.ip_addresses.filter(
                 alloc_type=IPADDRESS_TYPE.AUTO):
             if not auto_ip.ip:
+<<<<<<< TREE
                 assigned_ip = self._claim_auto_ip(
                     auto_ip, exclude_addresses=exclude_addresses)
                 if assigned_ip is not None:
                     assigned_addresses.append(assigned_ip)
                     exclude_addresses.add(str(assigned_ip.ip))
+=======
+                ngi, assigned_ip = self._claim_auto_ip(
+                    auto_ip, exclude_addresses)
+                if ngi is not None:
+                    affected_nodegroups.add(ngi.nodegroup)
+                if assigned_ip is not None:
+                    assigned_addresses.append(assigned_ip)
+                    exclude_addresses.add(unicode(assigned_ip.ip))
+        self._update_dns_zones(affected_nodegroups)
+>>>>>>> MERGE-SOURCE
         return assigned_addresses
 
     def _claim_auto_ip(self, auto_ip, exclude_addresses=[]):
+<<<<<<< TREE
         """Claim an IP address for the `auto_ip`."""
+=======
+        """Claim an IP address for the `auto_ip`.
+
+        :returns:NodeGroupInterface, new_ip_address
+        """
+        # Check if already has a hostmap allocated for this MAC address.
+>>>>>>> MERGE-SOURCE
         subnet = auto_ip.subnet
+<<<<<<< TREE
         if subnet is None:
             maaslog.error(
                 "Could not find subnet for interface %s." %
@@ -910,14 +954,93 @@
 
         # Allocate a new IP address from the entire subnet, excluding already
         # allocated addresses and ranges.
+=======
+        if subnet is None:
+            maaslog.error(
+                "Could not find subnet for interface %s." %
+                (self.get_log_string()))
+            raise StaticIPAddressUnavailable(
+                "Automatic IP address cannot be configured on interface %s "
+                "without an associated subnet." % self.get_name())
+
+        ngi = subnet.get_managed_cluster_interface()
+        if ngi is None:
+            # Couldn't find a managed cluster interface for this node. So look
+            # for any interface (must be an UNMANAGED interface, since any
+            # managed NodeGroupInterface MUST have a Subnet link) whose
+            # static or dynamic range is within the given subnet.
+            ngi = NodeGroupInterface.objects.get_by_managed_range_for_subnet(
+                subnet)
+
+        has_existing_mapping = False
+        has_static_range = False
+        has_dynamic_range = False
+
+        if ngi is not None:
+            has_existing_mapping = self._has_static_allocation_on_cluster(
+                ngi.nodegroup, get_subnet_family(subnet))
+            has_static_range = ngi.has_static_ip_range()
+            has_dynamic_range = ngi.has_dynamic_ip_range()
+
+        if not has_static_range and has_dynamic_range:
+            # This means we found a matching NodeGroupInterface, but only its
+            # dynamic range is defined. Since a dynamic range is defined, that
+            # means this subnet is NOT managed by MAAS (or it's misconfigured),
+            # so we cannot just hand out a random IP address and risk a
+            # duplicate IP address.
+            maaslog.error(
+                "Found matching NodeGroupInterface, but no static range has "
+                "been defined for %s. (did you mean to configure DHCP?) " %
+                (self.get_log_string()))
+            raise StaticIPAddressUnavailable(
+                "Cluster interface for %s only has a dynamic range. Configure "
+                "a static range, or reconfigure the interface." %
+                (self.get_name()))
+
+        if has_static_range:
+            # Allocate a new AUTO address from the static range.
+            network = ngi.network
+            static_ip_range_low = ngi.static_ip_range_low
+            static_ip_range_high = ngi.static_ip_range_high
+        else:
+            # We either found a NodeGroupInterface with no static or dynamic
+            # range, or we have a Subnet not associated with a
+            # NodeGroupInterface. This implies that it's okay to assign any
+            # unused IP address on the subnet.
+            network = subnet.get_ipnetwork()
+            static_ip_range_low, static_ip_range_high = (
+                get_first_and_last_usable_host_in_network(network))
+        in_use_ipset = subnet.get_ipranges_in_use()
+>>>>>>> MERGE-SOURCE
         new_ip = StaticIPAddress.objects.allocate_new(
+<<<<<<< TREE
             subnet=subnet, alloc_type=IPADDRESS_TYPE.AUTO,
             exclude_addresses=exclude_addresses)
+=======
+            network, static_ip_range_low, static_ip_range_high,
+            None, None, alloc_type=IPADDRESS_TYPE.AUTO,
+            subnet=subnet, exclude_addresses=exclude_addresses,
+            in_use_ipset=in_use_ipset)
+>>>>>>> MERGE-SOURCE
         self.ip_addresses.add(new_ip)
+<<<<<<< TREE
         maaslog.info("Allocated automatic IP address %s for %s." % (
             new_ip.ip,
             self.get_log_string()))
 
+=======
+        maaslog.info("Allocated automatic%s IP address %s for %s." % (
+            " static" if has_static_range else "", new_ip.ip,
+            self.get_log_string()))
+
+        if ngi is not None and not has_existing_mapping:
+            # Update DHCP (if needed).
+            self._update_host_maps(ngi.nodegroup, new_ip)
+
+        # If we made it this far, then the AUTO IP address has been assigned
+        # and the hostmap has been updated if needed. We can now remove the
+        # original empty AUTO IP address.
+>>>>>>> MERGE-SOURCE
         auto_ip.delete()
         return new_ip
 
@@ -940,6 +1063,7 @@
         subnet = auto_ip.subnet
         auto_ip.ip = None
         auto_ip.save()
+<<<<<<< TREE
         return subnet, auto_ip
 
     def get_ancestors(self):
@@ -971,6 +1095,154 @@
         for ancestor in ancestors:
             all_related |= ancestor.get_successors()
         return all_related
+=======
+
+        # If this IP address was registered on the cluster and now has been
+        # deleted we need to register the next assigned IP address to the
+        # cluster hostmap.
+        if registered_on_cluster and ngi is not None:
+            new_hostmap_ip = self._get_first_static_allocation_for_cluster(
+                ngi.nodegroup, ip_family)
+            if new_hostmap_ip is not None:
+                self._update_host_maps(ngi.nodegroup, new_hostmap_ip)
+        return ngi, auto_ip
+
+    def claim_static_ips(self, requested_address=None):
+        """Assign static IP addresses to this Interface.
+
+        Allocates one address per managed cluster interface connected to this
+        MAC. Typically this will be either just one IPv4 address, or an IPv4
+        address and an IPv6 address.
+
+        :param requested_address: Optional IP address to claim.  Must be in
+            the range defined on some cluter interface to which this
+            interface is related. If given, no allocations will be made on
+            any other cluster interfaces the MAC may be connected to.
+        :return: A list of :class:`StaticIPAddress`.  Returns empty if
+            the cluster_interface is not yet known, or the
+            static_ip_range_low/high values values are not set on the
+            cluster_interface.
+        """
+        # This method depends on a database isolation level of SERIALIZABLE
+        # (or perhaps REPEATABLE READ) to avoid race conditions.
+
+        # If the interface already has static addresses then we just return
+        # those.
+        existing_statics = [
+            ip_address
+            for ip_address in self.ip_addresses.filter(
+                alloc_type=IPADDRESS_TYPE.STICKY, ip__isnull=False)
+            if ip_address.ip
+        ]
+        if len(existing_statics) > 0:
+            return existing_statics
+
+        parent = self._get_parent_node()
+        # Get the last subnets this interface DHCP'd from. This with be either
+        # one IPv4, one IPv6, or both IPv4 and IPv6.
+        if parent is not None:
+            # If this interface is on a device then we need to look for
+            # discovered addresses on all the Node's interfaces.
+            discovered_ips = StaticIPAddress.objects.none()
+            for interface in parent.interface_set.all():
+                ip_addresses = interface.ip_addresses.filter(
+                    alloc_type=IPADDRESS_TYPE.DISCOVERED)
+                ip_addresses = ip_addresses.order_by(
+                    'id').select_related("subnet")
+                discovered_ips |= ip_addresses
+        else:
+            discovered_ips = self.ip_addresses.filter(
+                alloc_type=IPADDRESS_TYPE.DISCOVERED)
+            discovered_ips = discovered_ips.order_by(
+                'id').select_related("subnet")
+
+        discovered_subnets = [
+            discovered_ip.subnet for discovered_ip in discovered_ips
+        ]
+
+        if len(discovered_subnets) == 0:
+            # Backward compatibility code. When databases are migrated from 1.8
+            # and earlier, we may not have DISCOVERED addresses yet. So
+            # try to find a subnet on an attached cluster interface.
+            # (Note that get_cluster_interface() handles getting the parent
+            # node, if needed.)
+            for ngi in self.get_cluster_interfaces():
+                if ngi is not None and ngi.subnet is not None:
+                    discovered_subnets.append(ngi.subnet)
+
+        # This must be a set because it is highly possible that the parent
+        # has multiple subnets on the same interface or same subnet on multiple
+        # interfaces. We only want to allocate one ip address per subnet.
+        discovered_subnets = set(discovered_subnets)
+
+        if len(discovered_subnets) == 0:
+            node = self.node
+            if parent is not None:
+                node = parent
+            if node is None:
+                hostname = "<unknown>"
+            else:
+                hostname = "'%s'" % node.hostname
+            log_string = (
+                "%s: Attempted to claim a static IP address, but no "
+                "associated subnet could be found. (Recommission node %s "
+                "in order for MAAS to discover the subnet.)" %
+                (self.get_log_string(), hostname)
+            )
+            maaslog.warning(log_string)
+            raise StaticIPAddressExhaustion(log_string)
+
+        if requested_address is None:
+            # No requested address so claim a STATIC IP on all DISCOVERED
+            # subnets for this interface.
+            static_ips = []
+            for discovered_subnet in discovered_subnets:
+                ngi = discovered_subnet.get_managed_cluster_interface()
+                if ngi is not None:
+                    static_ips.append(
+                        self.link_subnet(
+                            INTERFACE_LINK_TYPE.STATIC, discovered_subnet))
+
+            # No valid subnets could be used to claim a STATIC IP address.
+            if not any(static_ips):
+                maaslog.error(
+                    "Attempted sticky IP allocation failed for %s: could not "
+                    "find a cluster interface.", self.get_log_string())
+                return []
+            else:
+                return static_ips
+        else:
+            # Find the DISCOVERED subnet that the requested_address falls into.
+            found_subnet = None
+            for discovered_subnet in discovered_subnets:
+                if (IPAddress(requested_address) in
+                        discovered_subnet.get_ipnetwork()):
+                    found_subnet = discovered_subnet
+                    break
+
+            if found_subnet:
+                return [
+                    self.link_subnet(
+                        INTERFACE_LINK_TYPE.STATIC, found_subnet,
+                        ip_address=requested_address),
+                ]
+            else:
+                raise StaticIPAddressOutOfRange(
+                    "requested_address '%s' is not in a managed subnet for "
+                    "interface '%s'." % (
+                        requested_address, self.get_name()))
+
+    def _get_parent_node(self):
+        """Return the parent node for this interface, if it exists (and this
+        interface belongs to a Device). Otherwise, return None.
+        """
+        if (self.node is not None and
+                not self.node.installable and
+                self.node.parent is not None):
+            return self.node.parent
+        else:
+            return None
+>>>>>>> MERGE-SOURCE
 
     def delete(self, remove_ip_address=True):
         # We set the _skip_ip_address_removal so the signal can use it to

=== modified file 'src/maasserver/models/migrations/create_default_storage_layout.py'
--- src/maasserver/models/migrations/create_default_storage_layout.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/models/migrations/create_default_storage_layout.py	2016-06-10 16:34:39 +0000
@@ -1,97 +1,201 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""Migration to create the default storage layout on the boot disk.
-
-WARNING: Although these methods will become obsolete very quickly, they
-cannot be removed, since they are used by the
-0181_initial_storage_layouts DataMigration. (changing them might also
-be futile unless a customer restores from a backup, since any bugs that occur
-will have already occurred, and this code will not be executed again.)
-
-Note: Each helper must have its dependencies on any model classes injected,
-since the migration environment is a skeletal replication of the 'real'
-database model. So each function takes as parameters the model classes it
-requires. Importing from the model is not allowed here. (but the unit tests
-do it, to ensure that the migrations meet validation requirements.)
-"""
-
-from __future__ import (
-    absolute_import,
-    print_function,
-    unicode_literals,
-    )
-
-str = None
-
-__metaclass__ = type
-__all__ = [
-    "clear_full_storage_configuration",
-]
-
-from datetime import datetime
-from uuid import uuid4
-
-from maasserver.enum import (
-    FILESYSTEM_TYPE,
-    PARTITION_TABLE_TYPE,
-)
-from maasserver.models.partition import (
-    MAX_PARTITION_SIZE_FOR_MBR,
-    PARTITION_ALIGNMENT_SIZE,
-)
-from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
-from maasserver.utils.converters import round_size_to_nearest_block
-
-
-def clear_full_storage_configuration(
-        node,
-        PhysicalBlockDevice, VirtualBlockDevice,
-        PartitionTable, Filesystem, FilesystemGroup):
-    """Clear's the full storage configuration for this node."""
-    physical_block_devices = PhysicalBlockDevice.objects.filter(node=node)
-    PartitionTable.objects.filter(
-        block_device__in=physical_block_devices).delete()
-    Filesystem.objects.filter(
-        block_device__in=physical_block_devices).delete()
-    for block_device in VirtualBlockDevice.objects.filter(node=node):
-        try:
-            block_device.filesystem_group.virtual_devices.all().delete()
-            block_device.filesystem_group.delete()
-        except FilesystemGroup.DoesNotExist:
-            # When a filesystem group has multiple virtual block devices
-            # it is possible that accessing `filesystem_group` will
-            # result in it already being deleted.
-            pass
-
-
-def create_flat_layout(
-        node, boot_disk,
-        PartitionTable, Partition, Filesystem):
-    """Create the flat layout for the boot disk."""
-    # Create the partition table and root partition.
-    now = datetime.now()
-    partition_table = PartitionTable.objects.create(
-        block_device=boot_disk, table_type=PARTITION_TABLE_TYPE.MBR,
-        created=now, updated=now)
-    total_size = 0
-    available_size = boot_disk.size - PARTITION_TABLE_EXTRA_SPACE
-    partition_size = round_size_to_nearest_block(
-        available_size, PARTITION_ALIGNMENT_SIZE, False)
-    max_mbr_size = round_size_to_nearest_block(
-        MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False)
-    if partition_size > max_mbr_size:
-        partition_size = max_mbr_size
-    available_size -= partition_size
-    total_size += partition_size
-    root_partition = Partition.objects.create(
-        partition_table=partition_table, size=partition_size, bootable=True,
-        created=now, updated=now, uuid=uuid4())
-    Filesystem.objects.create(
-        partition=root_partition,
-        fstype=FILESYSTEM_TYPE.EXT4,
-        label="root",
-        mount_point="/",
-        created=now,
-        updated=now,
-        uuid=uuid4())
+<<<<<<< TREE
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Migration to create the default storage layout on the boot disk.
+
+WARNING: Although these methods will become obsolete very quickly, they
+cannot be removed, since they are used by the
+0181_initial_storage_layouts DataMigration. (changing them might also
+be futile unless a customer restores from a backup, since any bugs that occur
+will have already occurred, and this code will not be executed again.)
+
+Note: Each helper must have its dependencies on any model classes injected,
+since the migration environment is a skeletal replication of the 'real'
+database model. So each function takes as parameters the model classes it
+requires. Importing from the model is not allowed here. (but the unit tests
+do it, to ensure that the migrations meet validation requirements.)
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "clear_full_storage_configuration",
+]
+
+from datetime import datetime
+from uuid import uuid4
+
+from maasserver.enum import (
+    FILESYSTEM_TYPE,
+    PARTITION_TABLE_TYPE,
+)
+from maasserver.models.partition import (
+    MAX_PARTITION_SIZE_FOR_MBR,
+    PARTITION_ALIGNMENT_SIZE,
+)
+from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
+from maasserver.utils.converters import round_size_to_nearest_block
+
+
+def clear_full_storage_configuration(
+        node,
+        PhysicalBlockDevice, VirtualBlockDevice,
+        PartitionTable, Filesystem, FilesystemGroup):
+    """Clear's the full storage configuration for this node."""
+    physical_block_devices = PhysicalBlockDevice.objects.filter(node=node)
+    PartitionTable.objects.filter(
+        block_device__in=physical_block_devices).delete()
+    Filesystem.objects.filter(
+        block_device__in=physical_block_devices).delete()
+    for block_device in VirtualBlockDevice.objects.filter(node=node):
+        try:
+            block_device.filesystem_group.virtual_devices.all().delete()
+            block_device.filesystem_group.delete()
+        except FilesystemGroup.DoesNotExist:
+            # When a filesystem group has multiple virtual block devices
+            # it is possible that accessing `filesystem_group` will
+            # result in it already being deleted.
+            pass
+
+
+def create_flat_layout(
+        node, boot_disk,
+        PartitionTable, Partition, Filesystem):
+    """Create the flat layout for the boot disk."""
+    # Create the partition table and root partition.
+    now = datetime.now()
+    partition_table = PartitionTable.objects.create(
+        block_device=boot_disk, table_type=PARTITION_TABLE_TYPE.MBR,
+        created=now, updated=now)
+    total_size = 0
+    available_size = boot_disk.size - PARTITION_TABLE_EXTRA_SPACE
+    partition_size = round_size_to_nearest_block(
+        available_size, PARTITION_ALIGNMENT_SIZE, False)
+    max_mbr_size = round_size_to_nearest_block(
+        MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False)
+    if partition_size > max_mbr_size:
+        partition_size = max_mbr_size
+    available_size -= partition_size
+    total_size += partition_size
+    root_partition = Partition.objects.create(
+        partition_table=partition_table, size=partition_size, bootable=True,
+        created=now, updated=now, uuid=uuid4())
+    Filesystem.objects.create(
+        partition=root_partition,
+        fstype=FILESYSTEM_TYPE.EXT4,
+        label="root",
+        mount_point="/",
+        created=now,
+        updated=now,
+        uuid=uuid4())
+=======
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Migration to create the default storage layout on the boot disk.
+
+WARNING: Although these methods will become obsolete very quickly, they
+cannot be removed, since they are used by the
+0181_initial_storage_layouts DataMigration. (changing them might also
+be futile unless a customer restores from a backup, since any bugs that occur
+will have already occurred, and this code will not be executed again.)
+
+Note: Each helper must have its dependencies on any model classes injected,
+since the migration environment is a skeletal replication of the 'real'
+database model. So each function takes as parameters the model classes it
+requires. Importing from the model is not allowed here. (but the unit tests
+do it, to ensure that the migrations meet validation requirements.)
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "clear_full_storage_configuration",
+    "create_lvm_layout",
+]
+
+from datetime import datetime
+from uuid import uuid4
+
+from maasserver.enum import (
+    FILESYSTEM_GROUP_TYPE,
+    FILESYSTEM_TYPE,
+    PARTITION_TABLE_TYPE,
+)
+from maasserver.models.filesystemgroup import LVM_PE_SIZE
+from maasserver.models.partition import (
+    MAX_PARTITION_SIZE_FOR_MBR,
+    MIN_PARTITION_SIZE,
+    PARTITION_ALIGNMENT_SIZE,
+)
+from maasserver.models.partitiontable import PARTITION_TABLE_EXTRA_SPACE
+from maasserver.utils.converters import round_size_to_nearest_block
+
+
+def clear_full_storage_configuration(
+        node,
+        PhysicalBlockDevice, VirtualBlockDevice,
+        PartitionTable, Filesystem, FilesystemGroup):
+    """Clear's the full storage configuration for this node."""
+    physical_block_devices = PhysicalBlockDevice.objects.filter(node=node)
+    PartitionTable.objects.filter(
+        block_device__in=physical_block_devices).delete()
+    Filesystem.objects.filter(
+        block_device__in=physical_block_devices).delete()
+    for block_device in VirtualBlockDevice.objects.filter(node=node):
+        try:
+            block_device.filesystem_group.virtual_devices.all().delete()
+            block_device.filesystem_group.delete()
+        except FilesystemGroup.DoesNotExist:
+            # When a filesystem group has multiple virtual block devices
+            # it is possible that accessing `filesystem_group` will
+            # result in it already being deleted.
+            pass
+
+
+def create_flat_layout(
+        node, boot_disk,
+        PartitionTable, Partition, Filesystem):
+    """Create the flat layout for the boot disk."""
+    # Create the partition table and root partition.
+    now = datetime.now()
+    partition_table = PartitionTable.objects.create(
+        block_device=boot_disk, table_type=PARTITION_TABLE_TYPE.MBR,
+        created=now, updated=now)
+    total_size = 0
+    available_size = boot_disk.size - PARTITION_TABLE_EXTRA_SPACE
+    partition_size = round_size_to_nearest_block(
+        available_size, PARTITION_ALIGNMENT_SIZE, False)
+    max_mbr_size = round_size_to_nearest_block(
+        MAX_PARTITION_SIZE_FOR_MBR, PARTITION_ALIGNMENT_SIZE, False)
+    if partition_size > max_mbr_size:
+        partition_size = max_mbr_size
+    available_size -= partition_size
+    total_size += partition_size
+    root_partition = Partition.objects.create(
+        partition_table=partition_table, size=partition_size, bootable=True,
+        created=now, updated=now, uuid=uuid4())
+    Filesystem.objects.create(
+        partition=root_partition,
+        fstype=FILESYSTEM_TYPE.EXT4,
+        label="root",
+        mount_point="/",
+        created=now,
+        updated=now,
+        uuid=uuid4())
+>>>>>>> MERGE-SOURCE

=== modified file 'src/maasserver/models/migrations/populate_subnets_helper.py'
=== modified file 'src/maasserver/models/migrations/tests/test_create_default_storage_layout.py'
--- src/maasserver/models/migrations/tests/test_create_default_storage_layout.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/models/migrations/tests/test_create_default_storage_layout.py	2016-06-10 16:34:39 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
@@ -135,3 +136,152 @@
                 label="root",
                 mount_point="/",
                 ))
+=======
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for the `0181_initial_storage_layouts` migration.
+
+WARNING: These tests will become obsolete very quickly, as they are testing
+migrations against fields that may be removed. When these tests become
+obsolete, they should be skipped. The tests should be kept until at least
+the next release cycle (through MAAS 1.9) in case any bugs with this migration
+occur.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from maasserver.enum import (
+    FILESYSTEM_GROUP_TYPE,
+    FILESYSTEM_TYPE,
+)
+from maasserver.models import (
+    Filesystem,
+    FilesystemGroup,
+    Partition,
+    PartitionTable,
+    PhysicalBlockDevice,
+    VirtualBlockDevice,
+    VolumeGroup,
+)
+from maasserver.models.migrations.create_default_storage_layout import (
+    clear_full_storage_configuration,
+    create_flat_layout,
+)
+from maasserver.testing.factory import factory
+from maasserver.testing.orm import reload_object
+from maasserver.testing.testcase import MAASServerTestCase
+from testtools.matchers import (
+    Is,
+    MatchesStructure,
+    Not,
+)
+
+
+class TestClearFullStorageConfigration(MAASServerTestCase):
+
+    def test__clears_all_objects(self):
+        node = factory.make_Node()
+        physical_block_devices = [
+            factory.make_PhysicalBlockDevice(node=node, size=10 * 1000 ** 3)
+            for _ in range(3)
+            ]
+        filesystem = factory.make_Filesystem(
+            block_device=physical_block_devices[0])
+        partition_table = factory.make_PartitionTable(
+            block_device=physical_block_devices[1])
+        partition = factory.make_Partition(partition_table=partition_table)
+        fslvm = factory.make_Filesystem(
+            block_device=physical_block_devices[2],
+            fstype=FILESYSTEM_TYPE.LVM_PV)
+        vgroup = factory.make_FilesystemGroup(
+            group_type=FILESYSTEM_GROUP_TYPE.LVM_VG, filesystems=[fslvm])
+        vbd1 = factory.make_VirtualBlockDevice(
+            filesystem_group=vgroup, size=2 * 1000 ** 3)
+        vbd2 = factory.make_VirtualBlockDevice(
+            filesystem_group=vgroup, size=3 * 1000 ** 3)
+        filesystem_on_vbd1 = factory.make_Filesystem(
+            block_device=vbd1, fstype=FILESYSTEM_TYPE.LVM_PV)
+        vgroup_on_vgroup = factory.make_FilesystemGroup(
+            group_type=FILESYSTEM_GROUP_TYPE.LVM_VG,
+            filesystems=[filesystem_on_vbd1])
+        vbd3_on_vbd1 = factory.make_VirtualBlockDevice(
+            filesystem_group=vgroup_on_vgroup, size=1 * 1000 ** 3)
+        clear_full_storage_configuration(
+            node,
+            PhysicalBlockDevice=PhysicalBlockDevice,
+            VirtualBlockDevice=VirtualBlockDevice,
+            PartitionTable=PartitionTable,
+            Filesystem=Filesystem,
+            FilesystemGroup=FilesystemGroup)
+        for pbd in physical_block_devices:
+            self.expectThat(
+                reload_object(pbd), Not(Is(None)),
+                "Physical block device should not have been deleted.")
+        self.expectThat(
+            reload_object(filesystem), Is(None),
+            "Filesystem should have been removed.")
+        self.expectThat(
+            reload_object(partition_table), Is(None),
+            "PartitionTable should have been removed.")
+        self.expectThat(
+            reload_object(partition), Is(None),
+            "Partition should have been removed.")
+        self.expectThat(
+            reload_object(fslvm), Is(None),
+            "LVM PV Filesystem should have been removed.")
+        self.expectThat(
+            reload_object(vgroup), Is(None),
+            "Volume group should have been removed.")
+        self.expectThat(
+            reload_object(vbd1), Is(None),
+            "Virtual block device should have been removed.")
+        self.expectThat(
+            reload_object(vbd2), Is(None),
+            "Virtual block device should have been removed.")
+        self.expectThat(
+            reload_object(filesystem_on_vbd1), Is(None),
+            "Filesystem on virtual block device should have been removed.")
+        self.expectThat(
+            reload_object(vgroup_on_vgroup), Is(None),
+            "Volume group on virtual block device should have been removed.")
+        self.expectThat(
+            reload_object(vbd3_on_vbd1), Is(None),
+            "Virtual block device on another virtual block device should have "
+            "been removed.")
+
+
+class TestCreateFlatLayout(MAASServerTestCase):
+
+    def test__creates_layout_for_1TiB_disk(self):
+        node = factory.make_Node(with_boot_disk=False)
+        boot_disk = factory.make_PhysicalBlockDevice(
+            node=node, size=1024 ** 4, block_size=512)
+        create_flat_layout(
+            node,
+            boot_disk,
+            PartitionTable=PartitionTable,
+            Partition=Partition,
+            Filesystem=Filesystem)
+
+        # Validate the filesystem on the root partition.
+        partition_table = boot_disk.get_partitiontable()
+        partitions = partition_table.partitions.order_by('id').all()
+        root_partition = partitions[0]
+        self.assertThat(
+            root_partition.get_effective_filesystem(),
+            MatchesStructure.byEquality(
+                fstype=FILESYSTEM_TYPE.EXT4,
+                label="root",
+                mount_point="/",
+                ))
+>>>>>>> MERGE-SOURCE

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2016-06-08 16:11:14 +0000
+++ src/maasserver/models/node.py	2016-06-10 16:34:39 +0000
@@ -996,6 +996,7 @@
                 event_action=action,
                 event_description=description)
 
+<<<<<<< TREE
     def storage_layout_issues(self):
         """Return any errors with the storage layout.
 
@@ -1067,6 +1068,78 @@
                 "deploy this node.")
         return issues
 
+=======
+    def storage_layout_issues(self):
+        """Return any errors with the storage layout.
+
+        Checks that the node has / mounted. If / is mounted on bcache check
+        that /boot is mounted and is not on bcache."""
+        def on_bcache(obj):
+            if obj.type == "physical":
+                return False
+            elif obj.type == "partition":
+                return on_bcache(obj.partition_table.block_device)
+            for parent in obj.virtualblockdevice.get_parents():
+                if((parent.type != "physical" and on_bcache(parent)) or
+                    (parent.get_effective_filesystem().fstype in
+                     [FILESYSTEM_TYPE.BCACHE_CACHE,
+                      FILESYSTEM_TYPE.BCACHE_BACKING])):
+                    return True
+            return False
+
+        has_boot = False
+        root_mounted = False
+        root_on_bcache = False
+        boot_mounted = False
+
+        for block_device in self.blockdevice_set.all():
+            if block_device.is_boot_disk():
+                has_boot = True
+            pt = block_device.get_partitiontable()
+            if pt is not None:
+                for partition in pt.partitions.all():
+                    fs = partition.get_effective_filesystem()
+                    if fs is None:
+                        continue
+                    if fs.mount_point == '/':
+                        root_mounted = True
+                        if on_bcache(block_device):
+                            root_on_bcache = True
+                    elif (fs.mount_point == '/boot' and
+                          not on_bcache(block_device)):
+                        boot_mounted = True
+            else:
+                fs = block_device.get_effective_filesystem()
+                if fs is None:
+                    continue
+                if fs.mount_point == '/':
+                    root_mounted = True
+                    if on_bcache(block_device):
+                        root_on_bcache = True
+                elif fs.mount_point == '/boot' and not on_bcache(block_device):
+                    boot_mounted = True
+        issues = []
+        if not has_boot:
+            issues.append(
+                "Specify a storage device to be able to deploy this node.")
+        if not root_mounted:
+            issues.append(
+                "Mount the root '/' filesystem to be able to deploy this "
+                "node.")
+        if root_mounted and root_on_bcache and not boot_mounted:
+            issues.append(
+                "This node cannot be deployed because it cannot boot from a "
+                "bcache volume. Mount /boot on a non-bcache device to be "
+                "able to deploy this node.")
+        if (not boot_mounted and "arm64" in self.architecture and
+                self.get_bios_boot_method() != "uefi"):
+            issues.append(
+                "This node cannot be deployed because it needs a separate "
+                "/boot partition.  Mount /boot on a device to be able to "
+                "deploy this node.")
+        return issues
+
+>>>>>>> MERGE-SOURCE
     def on_network(self):
         """Return true if the node is connected to a managed network."""
         for interface in self.interface_set.all():

=== added file 'src/maasserver/models/nodegroupinterface.py.OTHER'
--- src/maasserver/models/nodegroupinterface.py.OTHER	1970-01-01 00:00:00 +0000
+++ src/maasserver/models/nodegroupinterface.py.OTHER	2016-06-10 16:34:39 +0000
@@ -0,0 +1,764 @@
+# Copyright 2012-2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Model definition for NodeGroupInterface."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'NodeGroupInterface',
+    ]
+
+
+from textwrap import dedent
+
+from django.core.exceptions import ValidationError
+from django.db.models import (
+    CharField,
+    ForeignKey,
+    IntegerField,
+    Manager,
+    PROTECT,
+)
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from maasserver import DefaultMeta
+from maasserver.enum import (
+    IPADDRESS_TYPE,
+    NODEGROUP_STATUS,
+    NODEGROUPINTERFACE_MANAGEMENT,
+    NODEGROUPINTERFACE_MANAGEMENT_CHOICES,
+    NODEGROUPINTERFACE_MANAGEMENT_CHOICES_DICT,
+)
+from maasserver.exceptions import StaticIPAddressForbidden
+from maasserver.fields import (
+    MAASIPAddressField,
+    VerboseRegexValidator,
+)
+from maasserver.models.cleansave import CleanSave
+from maasserver.models.nodegroup import NodeGroup
+from maasserver.models.staticipaddress import StaticIPAddress
+from maasserver.models.timestampedmodel import TimestampedModel
+from netaddr import (
+    IPAddress,
+    IPNetwork,
+)
+from netaddr.core import AddrFormatError
+from provisioningserver.logger import get_maas_logger
+from provisioningserver.utils.network import (
+    intersect_iprange,
+    make_ipaddress,
+    make_iprange,
+    make_network,
+)
+
+
+maaslog = get_maas_logger("nodegroupinterface")
+
+
+class NodeGroupInterfaceManager(Manager):
+    """Manager for NodeGroupInterface objects"""
+
+    find_by_network_for_static_allocation_query = dedent("""\
+    SELECT ngi.*
+      FROM maasserver_nodegroup AS ng,
+           maasserver_nodegroupinterface AS ngi,
+           maasserver_subnet AS subnet
+     WHERE ng.status = %s
+       AND ngi.nodegroup_id = ng.id
+       AND ngi.subnet_id = subnet.id
+       AND ngi.static_ip_range_low IS NOT NULL
+       AND ngi.static_ip_range_high IS NOT NULL
+       AND (ngi.ip & netmask(subnet.cidr)) = (INET %s)
+     ORDER BY ng.id, ngi.id
+    """)
+
+    def find_by_network_for_static_allocation(self, network):
+        """Find all cluster interfaces with the given network.
+
+        Furthermore, each interface must also have a static range defined.
+        """
+        assert isinstance(network, IPNetwork), (
+            "%r is not an IPNetwork" % (network,))
+        return self.raw(
+            self.find_by_network_for_static_allocation_query,
+            [NODEGROUP_STATUS.ENABLED, network.network.format()])
+
+    def get_by_network_for_static_allocation(self, network):
+        """Return the first cluster interface with the given network.
+
+        Furthermore, the interface must also have a static range defined.
+        """
+        assert isinstance(network, IPNetwork), (
+            "%r is not an IPNetwork" % (network,))
+        interfaces = self.raw(
+            self.find_by_network_for_static_allocation_query + " LIMIT 1",
+            [NODEGROUP_STATUS.ENABLED, network.network.format()])
+        for interface in interfaces:
+            return interface  # This is stable because the query is ordered.
+        else:
+            return None
+
+    find_by_address_query = dedent("""\
+    SELECT ngi.*
+      FROM maasserver_nodegroup AS ng,
+           maasserver_nodegroupinterface AS ngi,
+           maasserver_subnet AS subnet
+     WHERE ng.status = %s
+       AND ngi.nodegroup_id = ng.id
+       AND ngi.subnet_id = subnet.id
+       AND (ngi.ip & netmask(subnet.cidr)) = (INET %s & netmask(subnet.cidr))
+     ORDER BY ng.id, ngi.id
+    """)
+
+    def find_by_address(self, address):
+        """Find all cluster interfaces for a given address."""
+        assert isinstance(address, IPAddress), (
+            "%r is not an IPAddress" % (address,))
+        return self.raw(
+            self.find_by_address_query,
+            [NODEGROUP_STATUS.ENABLED, address.format()])
+
+    def get_by_address(self, address):
+        """Return the first interface that could contain `address`."""
+        assert isinstance(address, IPAddress), (
+            "%r is not an IPAddress" % (address,))
+        interfaces = self.raw(
+            self.find_by_address_query + " LIMIT 1",
+            [NODEGROUP_STATUS.ENABLED, address.format()])
+        for interface in interfaces:
+            return interface  # This is stable because the query is ordered.
+        else:
+            return None
+
+    find_by_address_for_static_allocation_query = dedent("""\
+    SELECT ngi.*
+      FROM maasserver_nodegroup AS ng,
+           maasserver_nodegroupinterface AS ngi,
+           maasserver_subnet AS subnet
+     WHERE ng.status = %s
+       AND ngi.nodegroup_id = ng.id
+       AND ngi.subnet_id = subnet.id
+       AND ngi.static_ip_range_low IS NOT NULL
+       AND ngi.static_ip_range_high IS NOT NULL
+       AND (ngi.ip & netmask(subnet.cidr)) = (INET %s & netmask(subnet.cidr))
+     ORDER BY ng.id, ngi.id
+    """)
+
+    def find_by_address_for_static_allocation(self, address):
+        """Find all cluster interfaces for the given address.
+
+        Furthermore, each interface must also have a static range defined.
+        """
+        assert isinstance(address, IPAddress), (
+            "%r is not an IPAddress" % (address,))
+        return self.raw(
+            self.find_by_address_for_static_allocation_query,
+            [NODEGROUP_STATUS.ENABLED, address.format()])
+
+    def get_by_address_for_static_allocation(self, address):
+        """Return the first interface that could contain `address`.
+
+        Furthermore, the interface must also have a static range defined.
+        """
+        assert isinstance(address, IPAddress), (
+            "%r is not an IPAddress" % (address,))
+        interfaces = self.raw(
+            self.find_by_address_for_static_allocation_query + " LIMIT 1",
+            [NODEGROUP_STATUS.ENABLED, address.format()])
+        for interface in interfaces:
+            return interface  # This is stable because the query is ordered.
+        else:
+            return None
+
+    find_by_managed_range_for_subnet_query = dedent("""\
+    SELECT ngi.*
+        FROM
+            maasserver_subnet AS subnet,
+            maasserver_nodegroupinterface AS ngi,
+            maasserver_nodegroup AS ng
+        WHERE
+            ngi.nodegroup_id = ng.id AND
+            ng.status = 1 AND /* NodeGroup must be ENABLED */
+            ((inet(ngi.ip_range_low) << network(subnet.cidr) AND
+            inet(ngi.ip_range_high) << network(subnet.cidr))
+            OR (inet(ngi.static_ip_range_low) << network(subnet.cidr) AND
+            inet(ngi.static_ip_range_high) << network(subnet.cidr)))
+            AND subnet.id = %s
+        /* Prefer static ranges, since that's how we'll allocate addresses. */
+        ORDER BY ngi.static_ip_range_low DESC NULLS LAST, ngi.id
+    """)
+
+    def get_by_managed_range_for_subnet(self, subnet):
+        """Return the first interface that could contain `address` in its
+        dynamic or static range. (Prefer interfaces static ranges.)
+        """
+        # Circular imports
+        from maasserver.models import Subnet
+        assert isinstance(subnet, Subnet), (
+            "%r is not a Subnet" % (subnet,))
+        interfaces = self.raw(
+            self.find_by_managed_range_for_subnet_query + " LIMIT 1",
+            [subnet.id])
+        for interface in interfaces:
+            return interface  # This is stable because the query is ordered.
+        else:
+            return None
+
+    def clear_dynamic_range_for_colliding_allocations(self):
+        """If there are any managed NodeGroupInterfaces that have allocated
+        addresses inside the dynamic range, then log an error and clear the
+        dynamic range.  Called from inner_start_up.
+
+        See https://launchpad.net/bugs/1536604.
+        """
+        for ngi in NodeGroupInterface.objects.exclude(
+                management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED):
+            used = StaticIPAddress.objects.filter(
+                ip__gte=ngi.ip_range_low).filter(
+                ip__lte=ngi.ip_range_high).exclude(
+                alloc_type=IPADDRESS_TYPE.DHCP).exclude(
+                alloc_type=IPADDRESS_TYPE.DISCOVERED)
+            if used.exists():
+                maaslog.error((
+                    "Disabling DHCP on cluster %s, interface %s because "
+                    "dynamic range includes reserved/allocated addresses." % (
+                        ngi.nodegroup.cluster_name, ngi.name)))
+                ngi.management = NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
+                ngi.save()
+
+
+def get_default_vlan():
+    from maasserver.models.vlan import VLAN
+    return VLAN.objects.get_default_vlan()
+
+
+def raise_if_address_inside_dynamic_range(requested_address, fabric=None):
+    """
+    Checks if the specified IP address, inside the specified fabric,
+    is inside a MAAS-managed dynamic range.
+
+    :raises: StaticIPAddressForbidden if the address occurs within
+        an existing dynamic range within the specified fabric.
+    """
+    if fabric is not None:
+        raise NotImplementedError("Fabrics are not yet supported.")
+
+    requested_address_ip = IPAddress(requested_address)
+    for interface in NodeGroupInterface.objects.all():
+        if interface.is_managed:
+            dynamic_range = interface.get_dynamic_ip_range()
+            if requested_address_ip in dynamic_range:
+                raise StaticIPAddressForbidden(
+                    "Requested IP address %s is in a dynamic range." %
+                    requested_address)
+
+
+class NodeGroupInterface(CleanSave, TimestampedModel):
+    """Cluster interface.
+
+    Represents a network to which a given cluster controller is connected.
+    These interfaces are discovered automatically, but an admin can also
+    add/edit/remove them.
+
+    This class duplicates some of :class:`Network`, and adds settings for
+    managing DHCP.  Some day we hope to delegate the duplicated fields, and
+    have auto-discovery populate the :class:`Network` model along the way.
+    """
+
+    class Meta(DefaultMeta):
+        # The API identifies a NodeGroupInterface by cluster and name.
+        unique_together = ('nodegroup', 'name')
+
+    objects = NodeGroupInterfaceManager()
+
+    # Static IP of the network interface.
+    ip = MAASIPAddressField(
+        null=False, editable=True,
+        help_text="Static IP Address of the interface",
+        verbose_name="IP")
+
+    # The `NodeGroup` this interface belongs to.
+    nodegroup = ForeignKey(
+        'maasserver.NodeGroup', editable=True, null=False, blank=False)
+
+    vlan = ForeignKey(
+        'VLAN', default=get_default_vlan, editable=True, blank=False,
+        null=False, on_delete=PROTECT)
+
+    # Note: adding null=True temporarily; will be adjusted after a data
+    # migration occurs to create each subnet link.
+    subnet = ForeignKey(
+        'Subnet', editable=True, blank=True, null=True, on_delete=PROTECT)
+
+    # Name for this interface.  It must be unique within the cluster.
+    # The code ensures that this is never an empty string, but we do allow
+    # an empty string on the form.  The field defaults to a unique name based
+    # on the network interface name.
+    name = CharField(
+        blank=True, null=False, editable=True, max_length=255, default='',
+        validators=[VerboseRegexValidator('^[\w:.-]+$')],
+        help_text=(
+            "Identifying name for this cluster interface.  "
+            "Must be unique within the cluster, and consist only of letters, "
+            "digits, dashes, and colons."))
+
+    management = IntegerField(
+        choices=NODEGROUPINTERFACE_MANAGEMENT_CHOICES, editable=True,
+        default=NODEGROUPINTERFACE_MANAGEMENT.DEFAULT)
+
+    # DHCP server settings.
+    interface = CharField(
+        blank=True, editable=True, max_length=255, default='',
+        help_text="Network interface (e.g. 'eth1').")
+
+    ip_range_low = MAASIPAddressField(
+        editable=True, unique=False, blank=True, null=True, default=None,
+        verbose_name="DHCP dynamic IP range low value",
+        help_text="Lowest IP number of the range for dynamic IPs, used for "
+                  "enlistment, commissioning and unknown devices.")
+    ip_range_high = MAASIPAddressField(
+        editable=True, unique=False, blank=True, null=True, default=None,
+        verbose_name="DHCP dynamic IP range high value",
+        help_text="Highest IP number of the range for dynamic IPs, used for "
+                  "enlistment, commissioning and unknown devices.")
+    static_ip_range_low = MAASIPAddressField(
+        editable=True, unique=False, blank=True, null=True, default=None,
+        verbose_name="Static IP range low value",
+        help_text="Lowest IP number of the range for IPs given to allocated "
+                  "nodes, must be in same network as dynamic range.")
+    static_ip_range_high = MAASIPAddressField(
+        editable=True, unique=False, blank=True, null=True, default=None,
+        verbose_name="Static IP range high value",
+        help_text="Highest IP number of the range for IPs given to allocated "
+                  "nodes, must be in same network as dynamic range.")
+
+    # Foreign DHCP server address, if any, that was detected on this
+    # interface.
+    foreign_dhcp_ip = MAASIPAddressField(
+        null=True, default=None, editable=True, blank=True, unique=False)
+
+    @property
+    def broadcast_ip(self):
+        """Compatibility layer to return the broadcast IP of the attached
+        Subnet's CIDR (or an empty string if there is no Subnet).
+
+        (This property exists because NodeGroupInterface previously contained
+        a broadcast_ip field.)
+        """
+        if self.subnet is None:
+            return ''
+        return unicode(IPNetwork(self.subnet.cidr).broadcast)
+
+    @broadcast_ip.setter
+    def broadcast_ip(self, value):
+        # This is a derived field, so setting it is a no-op.
+        pass
+
+    @property
+    def subnet_mask(self):
+        """Compatibility layer to return the subnet mask of the attached
+        Subnet's CIDR (or an empty string if there is no Subnet).
+
+        (This property exists because NodeGroupInterface previously contained
+        a subnet_mask field.)
+        """
+        if self.subnet is None:
+            return ''
+        return unicode(IPNetwork(self.subnet.cidr).netmask)
+
+    @property
+    def router_ip(self):
+        """Compatibility layer to return the router IP address for the attached
+        Subnet (or an empty string if a router_id cannot be found).
+
+        (This property exists because NodeGroupInterface previously contained
+        a router_ip field.)
+        """
+        if self.subnet is None or not self.subnet.gateway_ip:
+            return ''
+        return unicode(self.subnet.gateway_ip)
+
+    @subnet_mask.setter
+    def subnet_mask(self, value):
+        """Compatability layer to create a Subnet model object, and link
+        it to this NodeGroupInterface (or use an existing Subnet).
+
+        Note: currently, this will create stale Subnet objects in the database
+        if the NodeGroupInterface is edited multiple times. In the future,
+        when a Subnet is "unlinked", we should check all objects that depend
+        on it to see if they should be moved to the new subnet, and/or
+        reject the change.
+        """
+        if value is None or value == "":
+            self.subnet = None
+            return
+
+        cidr = unicode(make_network(self.ip, value).cidr)
+        if self.subnet:
+            self.subnet.update_cidr(cidr)
+        else:
+            # Circular imports
+            from maasserver.models import Subnet, Space
+            subnet, _ = Subnet.objects.get_or_create(
+                cidr=cidr, defaults={
+                    'name': cidr,
+                    'cidr': cidr,
+                    'space': Space.objects.get_default_space()
+                })
+            self.subnet = subnet
+
+    @property
+    def network(self):
+        """Return the network defined by the interface's address and netmask.
+
+        :return: :class:`IPNetwork`, or `None` if the netmask is unset.
+        :raise AddrFormatError: If the combination of interface address and
+            subnet mask is malformed.
+        """
+        if self.subnet is None:
+            return None
+
+        netmask = IPNetwork(self.subnet.cidr).netmask
+        # Nullness check for GenericIPAddress fields is deliberately kept
+        # vague: MAASIPAddressField seems to represent nulls as empty
+        # strings.
+        if netmask:
+            return make_network(self.ip, netmask).cidr
+        else:
+            return None
+
+    @property
+    def is_managed(self):
+        """Return true if this interface is managed by MAAS."""
+        return self.management != NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED
+
+    def check_for_network_interface_clashes(self, exclude):
+        """Validate uniqueness rules for network interfaces.
+
+        This enforces the rules that there can be only one IPv4 cluster
+        interface on a given network interface on the cluster controller, and
+        that there can be only one IPv6 cluster interface with a static range
+        on a given network interface on the cluster controller.  Aliases and
+        VLANs count as separate network interfaces.
+
+        The IPv4 rule is inherent: a network interface (as seen in userspace)
+        can only be on one IPv4 subnet.  The IPv6 rule is needed because our
+        current way of configuring IPv6 addresses on nodes, in `/etc/network`,
+        does not support multiple addresses.  So a network interface on a node
+        can only be on one IPv6 subnet.  Since the node's network interface is
+        connected to the same network segment as the cluster controller's, that
+        means that the cluster controller can only manage static IP addresses
+        on one IPv6 subnet per network interface.
+        """
+        if 'ip' in exclude or 'nodegroup' in exclude or 'interface' in exclude:
+            return
+        ip_version = IPAddress(self.ip).version
+        similar_interfaces = self.nodegroup.nodegroupinterface_set.filter(
+            interface=self.interface).exclude(
+            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        if self.id is not None:
+            similar_interfaces = similar_interfaces.exclude(id=self.id)
+        potential_clashes = [
+            itf
+            for itf in similar_interfaces
+            if IPAddress(itf.ip).version == ip_version
+            ]
+        if ip_version == 4:
+            if potential_clashes != []:
+                raise ValidationError(
+                    "Another cluster interface already connects "
+                    "network interface %s to an IPv4 network."
+                    % self.interface)
+        elif self.static_ip_range_low and self.static_ip_range_high:
+            # Nullness checks for these IP addresses are deliberately vague
+            # because Django may represent them as either empty strings or
+            # None.
+            clashes = [
+                itf
+                for itf in potential_clashes
+                if itf.static_ip_range_low and itf.static_ip_range_high
+                ]
+            if clashes != []:
+                raise ValidationError(
+                    "Another cluster interface with a static address range "
+                    "already connects network interface %s to an IPv6 network."
+                    % self.interface)
+
+    def validate_unique(self, exclude=None):
+        """Validate against conflicting `NodeGroupInterface` objects."""
+        super(NodeGroupInterface, self).validate_unique(exclude=exclude)
+        if exclude is None:
+            exclude = []
+        self.check_for_network_interface_clashes(exclude)
+
+    def has_dynamic_ip_range(self):
+        """Returns `True` if this `NodeGroupInterface` has a dynamic IP
+        range specified."""
+        return self.ip_range_low and self.ip_range_high
+
+    def get_dynamic_ip_range(self):
+        """Returns a `MAASIPRange` for this `NodeGroupInterface`, if a dynamic
+        range is specified. Otherwise, returns `None`."""
+        if self.has_dynamic_ip_range():
+            return make_iprange(
+                self.ip_range_low, self.ip_range_high,
+                purpose='dynamic-range')
+        else:
+            return None
+
+    def has_static_ip_range(self):
+        """Returns `True` if this `NodeGroupInterface` has a static IP
+        range specified."""
+        return self.static_ip_range_low and self.static_ip_range_high
+
+    def get_static_ip_range(self):
+        """Returns a `MAASIPRange` for this `NodeGroupInterface`, if a static
+        range is specified. Otherwise, returns `None`."""
+        if self.has_static_ip_range():
+            return make_iprange(
+                self.static_ip_range_low, self.static_ip_range_high,
+                purpose='static-range')
+        else:
+            return None
+
+    def display_management(self):
+        """Return management status text as displayed to the user."""
+        return NODEGROUPINTERFACE_MANAGEMENT_CHOICES_DICT[self.management]
+
+    def __repr__(self):
+        return "<NodeGroupInterface %s,%s>" % (
+            self.nodegroup.uuid if self.nodegroup_id else None, self.name)
+
+    def clean_network_valid(self):
+        """Validate the network.
+
+        This validates that the network defined by `ip` and `subnet_mask` is
+        valid.
+        """
+        try:
+            network = self.network
+            if network and IPAddress(self.ip) not in self.network:
+                raise ValidationError(
+                    {'ip':
+                     ["Cluster IP address is not within specified subnet."]})
+            if (network and network.size < 8 and self.is_managed):
+                raise ValidationError(
+                    {'subnet_mask': ['Subnet is too small to manage.']})
+        except AddrFormatError as e:
+            # The interface's address is validated separately.  If the
+            # combination with the netmask is invalid, either there's already
+            # going to be a specific validation error for the IP address, or
+            # the failure is due to an invalid netmask.
+            # XXX mpontillo 2015-07-23: subnet - now that this is a property,
+            # is this appropriate?
+            raise ValidationError({'subnet_mask': [e.message]})
+
+    def clean_network_config_if_managed(self):
+        # If management is not 'UNMANAGED', all the network information
+        # should be provided.
+        if self.is_managed:
+            mandatory_fields = [
+                'interface',
+                'ip_range_low',
+                'ip_range_high',
+            ]
+            errors = {}
+            for field in mandatory_fields:
+                if not getattr(self, field):
+                    errors[field] = [
+                        "That field cannot be empty (unless that interface is "
+                        "'unmanaged')"]
+            if len(errors) == 0 and self.ip_range_low == self.ip_range_high:
+                errors.setdefault('ip_range_low', []).append([
+                    "Dynamic range cannot be one address."])
+                errors.setdefault('ip_range_high', []).append([
+                    "Dynamic range cannot be one address."])
+            if len(errors) != 0:
+                raise ValidationError(errors)
+
+    def manages_static_range(self):
+        """Is this a managed interface with a static IP range configured?"""
+        # Deliberately vague implicit conversion to bool: a blank IP address
+        # can show up internally as either None or an empty string.
+        return (
+            self.is_managed and
+            self.static_ip_range_low and
+            self.static_ip_range_high)
+
+    def clean_ip_ranges(self):
+        """Ensure that the static and dynamic ranges don't overlap."""
+        if not self.manages_static_range():
+            # Nothing to do; bail out.
+            return
+
+        errors = {}
+        ip_range_low = IPAddress(self.ip_range_low)
+        ip_range_high = IPAddress(self.ip_range_high)
+        static_ip_range_low = IPAddress(self.static_ip_range_low)
+        static_ip_range_high = IPAddress(self.static_ip_range_high)
+
+        message_base = (
+            "Lower bound %s is higher than upper bound %s")
+
+        static_range = {}
+        dynamic_range = {}
+
+        try:
+            static_range = make_iprange(
+                static_ip_range_low, static_ip_range_high)
+        except AddrFormatError:
+            message = message_base % (
+                static_ip_range_low, static_ip_range_high)
+            errors.update({
+                'static_ip_range_low': [message],
+                'static_ip_range_high': [message],
+                })
+
+        try:
+            dynamic_range = make_iprange(
+                ip_range_low, ip_range_high)
+        except AddrFormatError:
+            message = message_base % (ip_range_low, ip_range_high)
+            errors.update({
+                'ip_range_low': [message],
+                'ip_range_high': [message],
+                })
+
+        # This is a bit unattractive, but we can't use IPSet for
+        # large networks - it's far too slow. What we actually care
+        # about is whether the lows and highs of the static range
+        # fall within the dynamic range and vice-versa, which
+        # IPRange gives us.
+        ranges_overlap = (
+            static_ip_range_low in dynamic_range or
+            static_ip_range_high in dynamic_range or
+            ip_range_low in static_range or
+            ip_range_high in static_range
+        )
+        if ranges_overlap:
+            message = "Static and dynamic IP ranges may not overlap."
+            errors.update({
+                'ip_range_low': [message],
+                'ip_range_high': [message],
+                'static_ip_range_low': [message],
+                'static_ip_range_high': [message],
+                })
+
+        # And finally, make sure that there are no allocated addresses in the
+        # dynamic range.  This leads to lease parser errors when DHCP tries to
+        # give out the address that we already in use.
+        in_use = StaticIPAddress.objects.filter(
+            ip__gte=self.ip_range_low).filter(
+            ip__lte=self.ip_range_high).exclude(
+            alloc_type=IPADDRESS_TYPE.DHCP).exclude(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED)
+        if in_use.exists():
+            message = (
+                "Dynamic range may not have addresses already in use. "
+                "Conflicts with: %s" % (
+                    " ".join([sip.ip for sip in in_use])))
+            errors.update({
+                'ip_range_low': [message],
+                'ip_range_high': [message],
+            })
+
+        if errors:
+            raise ValidationError(errors)
+
+    def clean_overlapping_networks(self):
+        """Ensure that this interface's network doesn't overlap those of
+        other interfaces on this cluster.
+        """
+        try:
+            nodegroup = self.nodegroup
+        except NodeGroup.DoesNotExist:
+            # We're likely being called on nodegroup creation, so
+            # there's no nodegroup linked to this interface yet. Since
+            # we don't have a nodegroup we can't check whether any other
+            # interfaces on this nodegroup have overlapping network
+            # settings.
+            return
+
+        if not self.is_managed:
+            return
+
+        network = self.network
+        current_cluster_interfaces = (
+            NodeGroupInterface.objects.filter(nodegroup=nodegroup)
+            .exclude(management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+            .exclude(id=self.id))
+        network_overlaps_other_interfaces = any(
+            intersect_iprange(network, interface.network) is not None
+            for interface in current_cluster_interfaces
+            )
+        if network_overlaps_other_interfaces:
+            message = (
+                "This interface's network must not overlap with other "
+                "networks on this cluster.")
+            errors = {
+                'ip': [message],
+                'subnet_mask': [message],
+            }
+            raise ValidationError(errors)
+
+    def clean_fields(self, *args, **kwargs):
+        super(NodeGroupInterface, self).clean_fields(*args, **kwargs)
+        self.clean_network_valid()
+        self.clean_network_config_if_managed()
+        self.clean_ip_ranges()
+        self.clean_overlapping_networks()
+
+    def get_ipranges_in_use_on_ipnetwork(
+            self, ipnetwork, include_static_range=True):
+        """Returns a `set` of `MAASIPRange` objects for this
+        `NodeGroupInterface`, annotated with a purpose string indicating if
+        they are part of the dynamic range, static range, cluster IP, gateway
+        IP, or DNS server."""
+        assert isinstance(ipnetwork, IPNetwork)
+
+        ranges = set()
+        if self.has_dynamic_ip_range():
+            dynamic_range = self.get_dynamic_ip_range()
+            if dynamic_range in ipnetwork:
+                ranges.add(dynamic_range)
+
+        # The caller might want to exclude static ranges, if they will be
+        # separately looking at the static IP addresses assigned to the subnet.
+        if include_static_range:
+            if self.has_static_ip_range():
+                static_range = self.get_static_ip_range()
+                if static_range in ipnetwork:
+                    ranges.add(static_range)
+
+        if make_ipaddress(self.ip) in ipnetwork:
+            ranges.add(make_iprange(self.ip, purpose="cluster-ip"))
+
+        if self.subnet is not None:
+            gateway_ip = make_ipaddress(self.subnet.gateway_ip)
+            if gateway_ip and gateway_ip in ipnetwork:
+                ranges.add(make_iprange(
+                    self.subnet.gateway_ip, purpose="gateway-ip"))
+            if self.subnet.dns_servers is not None:
+                for server in self.subnet.dns_servers:
+                    if make_ipaddress(server) in ipnetwork:
+                        ranges.add(make_iprange(server, purpose="dns-server"))
+
+        return ranges
+
+
+@receiver(post_save, sender=NodeGroupInterface)
+def post_save_NodeGroupInterface(sender, instance, created, **kwargs):
+    """If a NodeGroupInterface is saved, ensure its corresponding Subnet
+    is also updated."""
+    # Note: If the NodeGroupInterface is being saved for the first time,
+    # the Subnet will have already been explicitly created already.
+    if not created and instance.subnet:
+        instance.subnet.save()

=== modified file 'src/maasserver/models/partition.py'
=== modified file 'src/maasserver/models/partitiontable.py'
=== modified file 'src/maasserver/models/signals/interfaces.py'
--- src/maasserver/models/signals/interfaces.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/models/signals/interfaces.py	2016-06-10 16:34:39 +0000
@@ -3,6 +3,7 @@
 
 """Respond to interface changes."""
 
+<<<<<<< TREE
 __all__ = [
     "signals",
 ]
@@ -14,6 +15,20 @@
     post_save,
     pre_delete,
 )
+=======
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from django.db.models.signals import post_save
+>>>>>>> MERGE-SOURCE
 from maasserver.enum import (
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
@@ -45,6 +60,14 @@
 signals = SignalsManager()
 
 
+INTERFACE_CLASSES = [
+    Interface,
+    PhysicalInterface,
+    BondInterface,
+    VLANInterface,
+]
+
+
 def interface_enabled_or_disabled(instance, old_values, **kwargs):
     """When an interface is enabled be sure at minimum a LINK_UP is created.
     When an interface is disabled make sure that all its links are removed,
@@ -70,10 +93,17 @@
                         ip_address, clearing_config=True)
 
 
+<<<<<<< TREE
 for klass in INTERFACE_CLASSES:
     signals.watch_fields(
         interface_enabled_or_disabled,
         klass, ['enabled'], delete=False)
+=======
+for klass in INTERFACE_CLASSES:
+    connect_to_field_change(
+        interface_enabled_or_disabled,
+        klass, ['enabled'], delete=False)
+>>>>>>> MERGE-SOURCE
 
 
 def interface_mtu_params_update(instance, old_values, **kwargs):
@@ -134,6 +164,7 @@
             parent.save()
 
 
+<<<<<<< TREE
 for klass in INTERFACE_CLASSES:
     signals.watch_fields(
         interface_mtu_params_update,
@@ -305,3 +336,50 @@
 
 # Enable all signals by default.
 signals.enable()
+=======
+for klass in INTERFACE_CLASSES:
+    connect_to_field_change(
+        interface_mtu_params_update,
+        klass, ['params'], delete=False)
+
+
+def update_bond_parents(sender, instance, created, **kwargs):
+    """Update bond parents when interface created."""
+    if instance.type == INTERFACE_TYPE.BOND:
+        for parent in instance.parents.all():
+            # Make sure the parent has not links as well, just to be sure.
+            parent.clear_all_links(clearing_config=True)
+            if parent.vlan != instance.vlan:
+                parent.vlan = instance.vlan
+                parent.save()
+
+
+for klass in INTERFACE_CLASSES:
+    post_save.connect(
+        update_bond_parents, sender=klass)
+
+
+def interface_vlan_update(instance, old_values, **kwargs):
+    """When an interfaces VLAN is changed we need to remove all
+    links if the VLAN is different.
+    """
+    new_vlan_id = instance.vlan_id
+    [old_vlan_id] = old_values
+    if new_vlan_id == old_vlan_id:
+        # Nothing changed do nothing.
+        return
+    if instance.node is None:
+        # Not assigned to a node. Nothing to do.
+        return
+
+    # Interface VLAN was changed on a machine or device. Remove all its
+    # links except the DISCOVERED ones.
+    instance.ip_addresses.exclude(
+        alloc_type=IPADDRESS_TYPE.DISCOVERED).delete()
+
+
+for klass in INTERFACE_CLASSES:
+    connect_to_field_change(
+        interface_vlan_update,
+        klass, ['vlan_id'], delete=False)
+>>>>>>> MERGE-SOURCE