Merge lp:~mpontillo/maas/bridge-interface-model-and-region-contract into lp:~maas-committers/maas/trunk

[Mike Pontillo]

Add BridgeInterface model and update region contract with rack.

 * Remove workaround that filtered interfaces with no parents on
   the rack. (they are now filtered on the region)
 * Create initial BridgeInterface model. Update enums.
 * Extract abstract base class for all interfaces with parents
   (ChildInterface). Create a corresponding ChildInterfaceForm.
 * Refactor rack code to report bridges to the region.
 * Minor changes to Javascript code to ensure bridges are
   consistently displayed (similar to bonds).

[Blake Rouse (blake-rouse)]

Wow, thats a lot of code. I would have preferred to see this in a few branches.

1. The model change.
2. The form change.
3. The rack interfaces change.
4. The UI change.

This really is 4 branches in 1. The good thing about it is this looks really, really good. You have really covered all the areas, including the UI which is great! Just a few comments that need to be fixed, look like just copy and paste failures.

Really with this branch I wonder how far it is just to allow users to create bridges. Curtin already supports the ability.

review: Approve

[Blake Rouse (blake-rouse)]

I think this is missing a migration to add the bridge type to interfaces. Not going to block you on it as its simple to add and generated anyway.

[Mike Pontillo (mpontillo)]

Thanks for the review. I think I addressed most of your comments, with the exception of logging a warning rather than throwing an exception if we can't find all of the parents an interface depends on in the database. As discussed on IRC, we'll leave this for a future branch, since we don't want bridges that include tap interfaces to throw exceptions. (we'll consider filtering them in other ways, but the topic needs more investigation than we should cover in this branch)

=== modified file 'src/maasserver/api/tests/test_interfaces.py'
--- src/maasserver/api/tests/test_interfaces.py	2016-03-07 23:20:52 +0000
+++ src/maasserver/api/tests/test_interfaces.py	2016-03-24 18:53:09 +0000
@@ -291,7 +291,7 @@
         self.assertEqual({
             "mac_address": [
                 "This MAC address is already in use by %s." % (
-                    interface_on_other_node.node.hostname)],
+                    interface_on_other_node.get_log_string())],
             }, json_load_bytes(response.content))
 
     def test_create_bond(self):
@@ -416,7 +416,7 @@
         self.assertEqual({
             "mac_address": ["This field cannot be blank."],
             "name": ["This field is required."],
-            "parents": ["A Bond interface must have one or more parents."],
+            "parents": ["A bond interface must have one or more parents."],
             }, json_load_bytes(response.content))
 
     def test_create_vlan(self):

=== modified file 'src/maasserver/enum.py'
--- src/maasserver/enum.py	2016-03-18 18:50:58 +0000
+++ src/maasserver/enum.py	2016-03-24 18:53:09 +0000
@@ -512,6 +512,7 @@
     # be changed.
     PHYSICAL = 'physical'
     BOND = 'bond'
+    BRIDGE = 'bridge'
     VLAN = 'vlan'
     ALIAS = 'alias'
     # Interface that is created when it is not linked to a node.
@@ -521,6 +522,7 @@
 INTERFACE_TYPE_CHOICES = (
     (INTERFACE_TYPE.PHYSICAL, "Physical interface"),
     (INTERFACE_TYPE.BOND, "Bond"),
+    (INTERFACE_TYPE.BRIDGE, "Bridge"),
     (INTERFACE_TYPE.VLAN, "VLAN interface"),
     (INTERFACE_TYPE.ALIAS, "Alias"),
     (INTERFACE_TYPE.UNKNOWN, "Unknown"),

=== modified file 'src/maasserver/forms_interface.py'
--- src/maasserver/forms_interface.py	2016-03-07 23:20:52 +0000
+++ src/maasserver/forms_interface.py	2016-03-24 18:53:09 +0000
@@ -24,6 +24,7 @@
 )
 from maasserver.models.interface import (
     BondInterface,
+    BridgeInterface,
     build_vlan_interface_name,
     Interface,
     InterfaceRelationship,
@@ -268,7 +269,94 @@
         return cleaned_data
 
 
-class BondInterfaceForm(InterfaceForm):
+class ChildInterfaceForm(InterfaceForm):
+    """Form used to create "child" interfaces (that is, interfaces which
+    require their "parent" interfaces in order to exist, such as bonds and
+    bridges.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__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):
+        """Validate that child interfaces cannot be created unless at least one
+        parent is present.
+        """
+        parents = self.get_clean_parents()
+        if parents is None:
+            return
+        # Ensure support for parthenogenesis.
+        if len(parents) < 1:
+            raise ValidationError(
+                "A %s interface must have one or more parents." %
+                self.Meta.model.get_type())
+        return parents
+
+    def _set_default_child_mac(self, parents):
+        """Sets the value of self.cleaned_data['mac_address'] based on either
+        the first parent (if the child interface is new), or a remaining parent
+        (if a parent with the current MAC was removed).
+        """
+        if self.instance.id is not None:
+            parent_macs = {
+                parent.mac_address.get_raw(): parent
+                for parent in self.instance.parents.all()
+                }
+        else:
+            parent_macs = {}
+        mac_not_changed = (
+            self.instance.id is not None and
+            self.cleaned_data["mac_address"] == self.instance.mac_address
+        )
+        if self.instance.id is None and 'mac_address' not in self.data:
+            # New bond without mac_address set, set it to the first
+            # parent mac_address.
+            self.cleaned_data['mac_address'] = str(
+                parents[0].mac_address)
+        elif (mac_not_changed and
+              self.instance.mac_address in parent_macs and
+              parent_macs[self.instance.mac_address] not in parents):
+            # Updating child where its mac_address comes from its parent
+            # and that parent is no longer part of this child. Update
+            # the mac_address to be one of the new parent MAC
+            # addresses.
+            self.cleaned_data['mac_address'] = str(
+                parents[0].mac_address)
+
+    def _set_default_vlan(self, parents):
+        """When creating the child, set VLAN to the same as the first parent
+        by default.
+        """
+        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
+
+    def _validate_parental_fidelity(self, parents):
+        """Check that all of the parent interfaces are not already in a
+        relationship before committing them to this child.
+        """
+        parents_with_other_children = {
+            parent.name
+            for parent in parents
+            for rel in parent.children_relationships.all()
+            if rel.child.id != self.instance.id
+        }
+        if parents_with_other_children:
+            set_form_error(
+                self, 'parents',
+                "Interfaces already in-use: %s." % (
+                    ', '.join(sorted(parents_with_other_children))))
+
+
+class BondInterfaceForm(ChildInterfaceForm):
     """Form used to create/edit a bond interface."""
 
     bond_mode = forms.ChoiceField(
@@ -305,24 +393,6 @@
             'name',
         )
 
-    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:
-            raise ValidationError(
-                "A Bond interface must have one or more parents.")
-        return parents
-
     def clean_vlan(self):
         new_vlan = self.cleaned_data.get('vlan')
         if new_vlan and new_vlan.fabric.get_default_vlan() != new_vlan:
@@ -331,70 +401,35 @@
         return new_vlan
 
     def clean(self):
-        cleaned_data = super(BondInterfaceForm, self).clean()
+        cleaned_data = super().clean()
         if self.fields_ok(['vlan', 'parents']):
             parents = self.cleaned_data.get('parents')
             # Set the mac_address if its missing and the interface is being
             # created.
             if parents:
-                if self.instance.id is not None:
-                    parent_macs = {
-                        parent.mac_address.get_raw(): parent
-                        for parent in self.instance.parents.all()
-                    }
-                mac_not_changed = (
-                    self.instance.id is not None and
-                    self.cleaned_data["mac_address"] == (
-                        self.instance.mac_address))
-                if self.instance.id is None and 'mac_address' not in self.data:
-                    # New bond without mac_address set, set it to the first
-                    # parent mac_address.
-                    self.cleaned_data['mac_address'] = str(
-                        parents[0].mac_address)
-                elif (mac_not_changed and
-                        self.instance.mac_address in parent_macs and
-                        parent_macs[self.instance.mac_address] not in parents):
-                    # Updating bond where its mac_address comes from its parent
-                    # and that parent is no longer part of this bond. Update
-                    # the mac_address to be one of the new parent MAC
-                    # addresses.
-                    self.cleaned_data['mac_address'] = str(
-                        parents[0].mac_address)
+                self._set_default_child_mac(parents)
+                self._validate_parental_fidelity(parents)
+                self._set_default_vlan(parents)
+                self._validate_parent_vlans_match(parents)
+        return cleaned_data
 
-                # Check that all of the parents are not already in use.
-                parents_with_other_children = {
-                    parent.name
-                    for parent in parents
-                    for rel in parent.children_relationships.all()
-                    if rel.child.id != self.instance.id
+    def _validate_parent_vlans_match(self, parents):
+        # 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')
+            parent_vlans = {
+                parent.vlan
+                for parent in parents
                 }
-                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
+            if parent_vlans != set([vlan]):
+                set_form_error(
+                    self, 'parents',
+                    "All parents must belong to the same VLAN.")
 
     def set_extra_parameters(self, interface, created):
         """Set the bond parameters as well."""
-        super(BondInterfaceForm, self).set_extra_parameters(interface, created)
+        super().set_extra_parameters(interface, created)
         # Set all the bond_* parameters.
         bond_fields = [
             field_name
@@ -414,8 +449,31 @@
                 interface.params[bond_field] = self.fields[bond_field].initial
 
 
+class BridgeInterfaceForm(ChildInterfaceForm):
+    """Form used to create/edit a bridge interface."""
+
+    class Meta:
+        model = BridgeInterface
+        fields = InterfaceForm.Meta.fields + (
+            'mac_address',
+            'name',
+        )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        if self.fields_ok(['vlan', 'parents']):
+            parents = self.cleaned_data.get('parents')
+            # Set the mac_address if its missing and the interface is being
+            # created.
+            if parents:
+                self._set_default_child_mac(parents)
+                self._validate_parental_fidelity(parents)
+                self._set_default_vlan(parents)
+        return cleaned_data
+
 INTERFACE_FORM_MAPPING = {
     INTERFACE_TYPE.PHYSICAL: PhysicalInterfaceForm,
     INTERFACE_TYPE.VLAN: VLANInterfaceForm,
     INTERFACE_TYPE.BOND: BondInterfaceForm,
+    INTERFACE_TYPE.BRIDGE: BridgeInterfaceForm,
 }

=== added file 'src/maasserver/migrations/builtin/maasserver/0046_add_bridge_interface_type.py'
--- src/maasserver/migrations/builtin/maasserver/0046_add_bridge_interface_type.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/builtin/maasserver/0046_add_bridge_interface_type.py	2016-03-24 18:53:09 +0000
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import (
+    migrations,
+    models,
+)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('maasserver', '0045_add_node_to_filesystem'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ChildInterface',
+            fields=[
+            ],
+            options={
+                'abstract': False,
+                'proxy': True,
+            },
+            bases=('maasserver.interface',),
+        ),
+        migrations.AlterField(
+            model_name='interface',
+            name='type',
+            field=models.CharField(choices=[('physical', 'Physical interface'), ('bond', 'Bond'), ('bridge', 'Bridge'), ('vlan', 'VLAN interface'), ('alias', 'Alias'), ('unknown', 'Unknown')], editable=False, max_length=20),
+        ),
+        migrations.CreateModel(
+            name='BridgeInterface',
+            fields=[
+            ],
+            options={
+                'verbose_name': 'Bridge',
+                'abstract': False,
+                'verbose_name_plural': 'Bridges',
+                'proxy': True,
+            },
+            bases=('maasserver.childinterface',),
+        ),
+    ]

=== modified file 'src/maasserver/models/__init__.py'
--- src/maasserver/models/__init__.py	2016-03-11 00:37:08 +0000
+++ src/maasserver/models/__init__.py	2016-03-24 18:53:09 +0000
@@ -102,6 +102,7 @@
 )
 from maasserver.models.interface import (
     BondInterface,
+    BridgeInterface,
     Interface,
     PhysicalInterface,
     UnknownInterface,
@@ -149,6 +150,7 @@
     BMC,
     Bcache,
     BondInterface,
+    BridgeInterface,
     BootResource,
     BootResourceFile,
     BootResourceSet,

=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2016-03-10 23:04:24 +0000
+++ src/maasserver/models/interface.py	2016-03-24 18:53:09 +0000
@@ -210,6 +210,12 @@
         else:
             return qs.filter(type=interface_type)
 
+    def get_interfaces_on_node_by_name(self, node, interface_names):
+        """Returns a list of Inteface objects on the specified node whose
+        names match the specified list of interface names.
+        """
+        return list(self.filter(node=node, name__in=interface_names))
+
     def get_by_ip(self, static_ip_address):
         """Given the specified StaticIPAddress, return the Interface it's on.
         """
@@ -280,6 +286,52 @@
             interface.save()
         return interface, created
 
+    def get_or_create_on_node(self, node, name, mac_address, parent_nics):
+        """Create an interface on the specified node, with the specified MAC
+        address and parent NICs.
+
+        This method is necessary because get_or_create() often offers too
+        simplistic an approach to interface matching. For example, if an
+        interface has been moved, its MAC has changed, or its dependencies
+        on other interfaces have changed.
+
+        This method attempts to update an existing interface, if a
+        match can be found. Otherwise, a new interface will be created.
+
+        If the interface being created is a replacement for an interface that
+        already exists, the caller is responsible for deleting it.
+        """
+        interface = self.get_queryset().filter(
+            Q(mac_address=mac_address) | Q(name=name) & Q(node=node)).first()
+        if interface is not None:
+            if interface.type != self.model.get_type():
+                # This means we found the interface on this node, but the type
+                # didn't match what we expected. This should not happen unless
+                # we changed the modeling of this interface type, or the admin
+                # intentionally changed the interface type.
+                interface.delete()
+                return self.get_or_create_on_node(
+                    node, name, mac_address, parent_nics)
+            interface.mac_address = mac_address
+            interface.name = name
+            interface.parents.clear()
+            for parent_nic in parent_nics:
+                InterfaceRelationship(
+                    child=interface, parent=parent_nic).save()
+            if interface.node.id != node.id:
+                # Bond with MAC address was on a different node. We need to
+                # move it to its new owner. In the process we delete all of its
+                # current links because they are completely wrong.
+                interface.ip_addresses.all().delete()
+                interface.node = node
+        else:
+            interface = self.create(
+                name=name, mac_address=mac_address, node=node)
+            for parent_nic in parent_nics:
+                InterfaceRelationship(
+                    child=interface, parent=parent_nic).save()
+        return interface
+
 
 class Interface(CleanSave, TimestampedModel):
 
@@ -356,7 +408,7 @@
         node = self.get_node()
         if node is not None:
             hostname = node.hostname
-        return "%s on %s" % (self.get_name(), hostname)
+        return "%s (%s) on %s" % (self.get_name(), self.type, hostname)
 
     def get_name(self):
         return self.name
@@ -1021,8 +1073,8 @@
             raise ValidationError({
                 "mac_address": [
                     "This MAC address is already in use by %s." % (
-                        other_interfaces[0].node.hostname)]
-                })
+                        other_interfaces[0].get_log_string())]
+            })
 
         # No parents are allow for a physical interface.
         if self.id is not None:
@@ -1030,19 +1082,16 @@
             if len(self.parents.all()) > 0:
                 raise ValidationError({
                     "parents": ["A physical interface cannot have parents."]
-                    })
-
-
-class BondInterface(Interface):
+                })
+
+
+class ChildInterface(Interface):
+    """Abstract class to represent interfaces which require parents in order
+    to operate.
+    """
 
     class Meta(Interface.Meta):
         proxy = True
-        verbose_name = "Bond"
-        verbose_name_plural = "Bonds"
-
-    @classmethod
-    def get_type(self):
-        return INTERFACE_TYPE.BOND
 
     def get_node(self):
         if self.id is None:
@@ -1064,14 +1113,14 @@
             }
             return True in is_enabled
 
-    def clean(self):
-        super(BondInterface, self).clean()
-        # Validate that the MAC address is not None.
-        if not self.mac_address:
-            raise ValidationError({
-                "mac_address": ["This field cannot be blank."]
-                })
+    def _validate_acceptable_parent_types(self, parent_types):
+        """Raises a ValidationError if the interface has parents which are not
+        allowed, given this interface type. (for example, only physical
+        interfaces can be bonded, and bridges cannot bridge other bridges.)
+        """
+        raise NotImplementedError()
 
+    def _validate_parent_interfaces(self):
         # Parent interfaces on this bond must be from the same node and can
         # only be physical interfaces.
         if self.id is not None:
@@ -1083,16 +1132,14 @@
                 raise ValidationError({
                     "parents": [
                         "Parent interfaces do not belong to the same node."]
-                    })
+                })
             parent_types = {
                 parent.get_type()
                 for parent in self.parents.all()
             }
-            if parent_types != set([INTERFACE_TYPE.PHYSICAL]):
-                raise ValidationError({
-                    "parents": ["Only physical interfaces can be bonded."]
-                    })
+            self._validate_acceptable_parent_types(parent_types)
 
+    def _validate_unique_or_parent_mac(self):
         # Validate that this bond interface is using either a new MAC address
         # or a MAC address from one of its parents. This validation is only
         # done once the interface has been saved once. That is because if its
@@ -1128,7 +1175,73 @@
                     "mac_address": [
                         "This MAC address is already in use by %s." % (
                             bad_interfaces[0].node.hostname)]
-                    })
+                })
+
+
+class BridgeInterface(ChildInterface):
+
+    class Meta(Interface.Meta):
+        proxy = True
+        verbose_name = "Bridge"
+        verbose_name_plural = "Bridges"
+
+    @classmethod
+    def get_type(self):
+        return INTERFACE_TYPE.BRIDGE
+
+    def _validate_acceptable_parent_types(self, parent_types):
+        """Validates that bridges cannot contain other bridges."""
+        if INTERFACE_TYPE.BRIDGE in parent_types:
+            raise ValidationError({
+                "parents": ["Bridges cannot contain other bridges."]
+            })
+
+    def clean(self):
+        super().clean()
+        # Validate that the MAC address is not None.
+        if not self.mac_address:
+            raise ValidationError({
+                "mac_address": ["This field cannot be blank."]
+            })
+        self._validate_parent_interfaces()
+        self._validate_unique_or_parent_mac()
+
+    def save(self, *args, **kwargs):
+        # Set the node of this bond to the same as its parents.
+        self.node = self.get_node()
+        # Set the enabled status based on its parents.
+        self.enabled = self.is_enabled()
+        super().save(*args, **kwargs)
+
+
+class BondInterface(ChildInterface):
+
+    class Meta(Interface.Meta):
+        proxy = True
+        verbose_name = "Bond"
+        verbose_name_plural = "Bonds"
+
+    @classmethod
+    def get_type(self):
+        return INTERFACE_TYPE.BOND
+
+    def clean(self):
+        super(BondInterface, self).clean()
+        # Validate that the MAC address is not None.
+        if not self.mac_address:
+            raise ValidationError({
+                "mac_address": ["This field cannot be blank."]
+            })
+
+        self._validate_parent_interfaces()
+        self._validate_unique_or_parent_mac()
+
+    def _validate_acceptable_parent_types(self, parent_types):
+        """Validates that bonds only include physical interfaces."""
+        if parent_types != {INTERFACE_TYPE.PHYSICAL}:
+            raise ValidationError({
+                "parents": ["Only physical interfaces can be bonded."]
+            })
 
     def save(self, *args, **kwargs):
         # Set the node of this bond to the same as its parents.
@@ -1195,13 +1308,20 @@
                     "parents": ["VLAN interface must have exactly one parent."]
                     })
             parent = parents[0]
-            if parent.get_type() not in [
-                    INTERFACE_TYPE.PHYSICAL, INTERFACE_TYPE.BOND]:
+            allowed_vlan_parent_types = (
+                INTERFACE_TYPE.PHYSICAL,
+                INTERFACE_TYPE.BOND,
+                INTERFACE_TYPE.BRIDGE
+            )
+            if parent.get_type() not in allowed_vlan_parent_types:
+                # XXX mpontillo 2016-06-23: we won't mention bridges in this
+                # error message, since users can't configure bridges on nodes.
                 raise ValidationError({
                     "parents": [
                         "VLAN interface can only be created on a physical "
-                        "or bond interface."]
-                    })
+                        "or bond interface."
+                    ]
+                })
 
     def save(self, *args, **kwargs):
         # Set the node of this VLAN to the same as its parents.
@@ -1242,7 +1362,7 @@
         if self.node is not None:
             raise ValidationError({
                 "node": ["This field must be blank."]
-                })
+            })
 
         # No other interfaces can have this MAC address.
         other_interfaces = Interface.objects.filter(
@@ -1254,7 +1374,7 @@
             raise ValidationError({
                 "mac_address": [
                     "This MAC address is already in use by %s." % (
-                        other_interfaces[0].node.hostname)]
+                        other_interfaces[0].get_log_string())]
                 })
 
         # Cannot have any parents.
@@ -1264,7 +1384,7 @@
             if len(parents) > 0:
                 raise ValidationError({
                     "parents": ["A unknown interface cannot have parents."]
-                    })
+                })
 
 
 INTERFACE_TYPE_MAPPING = {
@@ -1273,6 +1393,7 @@
     [
         PhysicalInterface,
         BondInterface,
+        BridgeInterface,
         VLANInterface,
         UnknownInterface,
     ]

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2016-03-17 19:57:42 +0000
+++ src/maasserver/models/node.py	2016-03-24 18:53:09 +0000
@@ -91,8 +91,8 @@
 from maasserver.models.filesystemgroup import FilesystemGroup
 from maasserver.models.interface import (
     BondInterface,
+    BridgeInterface,
     Interface,
-    InterfaceRelationship,
     PhysicalInterface,
     VLANInterface,
 )
@@ -2426,8 +2426,9 @@
         selecting the best possible default gateway IP. The criteria below
         is used to select the best possible gateway:
             1. Managed subnets over unmanaged subnets.
-            2. Bond interfaces over physical interfaces.
-            3. Node's boot interface over all other interfaces except bonds.
+            2. Bond and bridge interfaces over physical interfaces.
+            3. Node's boot interface over all other interfaces except bonds
+               and bridges.
             4. Physical interfaces over VLAN interfaces.
             5. Sticky IP links over user reserved IP links.
             6. User reserved IP links over auto IP links.
@@ -2470,6 +2471,7 @@
                 vlan.dhcp_on DESC,
                 CASE
                     WHEN interface.type = 'bond' THEN 1
+                    WHEN interface.type = 'bridge' THEN 1
                     WHEN interface.type = 'physical' AND
                         interface.id = node.boot_interface_id THEN 2
                     WHEN interface.type = 'physical' THEN 3
@@ -2983,10 +2985,10 @@
         }))
         for name in process_order:
             interface = self._update_interface(name, interfaces[name])
-            if interface.id in current_interfaces:
+            if interface is not None and interface.id in current_interfaces:
                 del current_interfaces[interface.id]
 
-        # Remove all the interfaces that no longer exits. We do this in reverse
+        # Remove all the interfaces that no longer exist. We do this in reverse
         # order so the child is deleted before the parent.
         deletion_order = {}
         for nic_id, nic in current_interfaces.items():
@@ -3015,6 +3017,8 @@
             return self._update_vlan_interface(name, config)
         elif config["type"] == "bond":
             return self._update_bond_interface(name, config)
+        elif config["type"] == "bridge":
+            return self._update_bridge_interface(name, config)
         else:
             raise ValueError(
                 "Unkwown interface type '%s' for '%s'." % (
@@ -3156,6 +3160,52 @@
                 interface, config["links"], force_vlan=True)
         return interface
 
+    def _update_child_interface(self, name, config, child_type):
+        """Update a child interface.
+
+        :param name: Name of the interface.
+        :param config: Interface dictionary that was parsed from
+            /etc/network/interfaces on the rack controller.
+        """
+        # Get all the parent interfaces for this interface. All the parents
+        # should exists because of the order the links are processed.
+        ifnames = config["parents"]
+        parent_nics = Interface.objects.get_interfaces_on_node_by_name(
+            self, ifnames)
+
+        # If we didn't create the parents yet, we need to know about it,
+        # because that indicates a potentially serious bug.
+        if len(config["parents"]) != len(parent_nics):
+            maaslog.warning(
+                "Could not find all parent interfaces for {ifname} "
+                "on {node_name}. Found: {modeled_interfaces}; "
+                "expected: {expected_interfaces}".format(
+                    ifname=name,
+                    node_name=self.hostname,
+                    modeled_interfaces=[
+                        iface.name for iface in parent_nics
+                    ].join(", "),
+                    expected_interfaces=ifnames.join(", ")))
+
+        # Ignore child interfaces that don't have parents. MAAS won't know what
+        # to do with them since they can't be connected to a fabric.
+        if len(parent_nics) == 0:
+            return None
+
+        mac_address = config["mac_address"]
+        interface = child_type.objects.get_or_create_on_node(
+            self, name, mac_address, parent_nics)
+
+        links = config["links"]
+        self._configure_vlan_from_links(interface, parent_nics, links)
+
+        # Update all the IP address on this interface. Fix the VLAN the
+        # interface belongs to so its the same as the links and all parents to
+        # be on the same VLAN.
+        update_ip_addresses = self._update_links(interface, links)
+        self._update_parent_vlans(interface, parent_nics, update_ip_addresses)
+        return interface
+
     def _update_bond_interface(self, name, config):
         """Update a bond interface.
 
@@ -3163,67 +3213,49 @@
         :param config: Interface dictionary that was parsed from
             /etc/network/interfaces on the rack controller.
         """
-        # Get all the parent interfaces for this bond. All the parents should
-        # exists because of the order the links are processed.
-        parent_nics = [
-            Interface.objects.get(node=self, name=parent_name)
-            for parent_name in config["parents"]
-        ]
-
-        # Create the bond interface. get_or_create will not work as the way
-        # parents of a bond can be removed or the MAC address can change. Do
-        # the best possible to update the existing bond, if not a new one will
-        # be created and the old one will be removed in `update_interfaces`.
-        mac_address = config["mac_address"]
-        interface = BondInterface.objects.filter(
-            Q(mac_address=mac_address) | Q(name=name) & Q(node=self)).first()
-        if interface is not None:
-            interface.mac_address = mac_address
-            interface.name = name
-            interface.parents.clear()
-            for parent_nic in parent_nics:
-                InterfaceRelationship(
-                    child=interface, parent=parent_nic).save()
-            if interface.node.id != self.id:
-                # Bond with MAC address was on a different node. We need to
-                # move it to its new owner. In the process we delete all of its
-                # current links because they are completely wrong.
-                interface.ip_addresses.all().delete()
-                interface.node = self
-        else:
-            interface = BondInterface.objects.create(
-                name=name, mac_address=mac_address, node=self)
-            for parent_nic in parent_nics:
-                InterfaceRelationship(
-                    child=interface, parent=parent_nic).save()
-
-        # Make sure that the VLAN on the bond is correct. When
-        # links exists on this bond we place it into the correct
+        return self._update_child_interface(name, config, BondInterface)
+
+    def _update_bridge_interface(self, name, config):
+        """Update a bridge interface.
+
+        :param name: Name of the interface.
+        :param config: Interface dictionary that was parsed from
+            /etc/network/interfaces on the rack controller.
+        """
+        return self._update_child_interface(name, config, BridgeInterface)
+
+    def _update_parent_vlans(
+            self, interface, parent_nics, update_ip_addresses):
+        """Given the specified interface model object, the specified list of
+        parent interfaces, and the specified list of static IP addresses,
+        update the parent interfaces to correspond to the VLAN found on the
+        subnet the IP address is allocated from.
+
+        If a static IP address is allocated, give preferential treatment to
+        the VLAN that IP address resides on.
+        """
+        linked_vlan = self._get_first_sticky_vlan_from_ip_addresses(
+            update_ip_addresses)
+        if linked_vlan is not None:
+            interface.vlan = linked_vlan
+            interface.save()
+            for parent_nic in parent_nics:
+                if parent_nic.vlan_id != linked_vlan.id:
+                    parent_nic.vlan = linked_vlan
+                    parent_nic.save()
+
+    def _configure_vlan_from_links(self, interface, parent_nics, links):
+        # Make sure that the VLAN on the interface is correct. When
+        # links exists on this interface we place it into the correct
         # VLAN. If it cannot be determined it is placed on the same fabric
         # as its first parent interface.
-        connected_to_subnets = self._get_connected_subnets(
-            config["links"])
+        connected_to_subnets = self._get_connected_subnets(links)
         if len(connected_to_subnets) == 0:
             # Not connected to any known subnets. We add it to the same
             # VLAN as its first parent.
             interface.vlan = parent_nics[0].vlan
         interface.save()
 
-        # Update all the IP address on this bond. Fix the VLAN the
-        # bond belongs to so its the same as the links and all parents to
-        # be on the same VLAN.
-        update_ip_addresses = self._update_links(interface, config["links"])
-        linked_vlan = self._get_first_sticky_vlan_from_ip_addresses(
-            update_ip_addresses)
-        if linked_vlan is not None:
-            interface.vlan = linked_vlan
-            interface.save()
-            for parent_nic in parent_nics:
-                if parent_nic.vlan_id != linked_vlan.id:
-                    parent_nic.vlan = linked_vlan
-                    parent_nic.save()
-        return interface
-
     def _get_connected_subnets(self, links):
         """Return a set of subnets that `links` belongs to."""
         subnets = set()

=== modified file 'src/maasserver/models/signals/interfaces.py'
--- src/maasserver/models/signals/interfaces.py	2016-03-07 23:20:52 +0000
+++ src/maasserver/models/signals/interfaces.py	2016-03-24 18:53:09 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Respond to interface changes."""
@@ -15,6 +15,7 @@
 )
 from maasserver.models import (
     BondInterface,
+    BridgeInterface,
     Interface,
     PhysicalInterface,
     VLAN,
@@ -27,6 +28,7 @@
     Interface,
     PhysicalInterface,
     BondInterface,
+    BridgeInterface,
     VLANInterface,
 ]
 
@@ -128,9 +130,9 @@
         klass, ['params'], delete=False)
 
 
-def update_bond_parents(sender, instance, created, **kwargs):
-    """Update bond parents when interface created."""
-    if instance.type == INTERFACE_TYPE.BOND:
+def update_interface_parents(sender, instance, created, **kwargs):
+    """Update parents when an interface is created."""
+    if instance.type in (INTERFACE_TYPE.BOND, INTERFACE_TYPE.BRIDGE):
         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)
@@ -141,7 +143,7 @@
 
 for klass in INTERFACE_CLASSES:
     signals.watch(
-        post_save, update_bond_parents,
+        post_save, update_interface_parents,
         sender=klass)
 
 

=== modified file 'src/maasserver/models/signals/tests/test_interfaces.py'
--- src/maasserver/models/signals/tests/test_interfaces.py	2016-03-07 23:20:52 +0000
+++ src/maasserver/models/signals/tests/test_interfaces.py	2016-03-24 18:53:09 +0000
@@ -126,14 +126,19 @@
             }, reload_object(physical3_interface).params)
 
 
-class TestUpdateBondParents(MAASServerTestCase):
+class TestUpdateChildInterfaceParents(MAASServerTestCase):
+
+    scenarios = (
+        ("bond", {"iftype": INTERFACE_TYPE.BOND}),
+        ("bridge", {"iftype": INTERFACE_TYPE.BRIDGE}),
+    )
 
     def test__updates_bond_parents(self):
         parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         parent2 = factory.make_Interface(
             INTERFACE_TYPE.PHYSICAL, node=parent1.node)
         bond = factory.make_Interface(
-            INTERFACE_TYPE.BOND, parents=[parent1, parent2])
+            self.iftype, parents=[parent1, parent2])
         self.assertEqual(bond.vlan, reload_object(parent1).vlan)
         self.assertEqual(bond.vlan, reload_object(parent2).vlan)
 
@@ -143,7 +148,7 @@
             INTERFACE_TYPE.PHYSICAL, node=parent1.node)
         static_ip = factory.make_StaticIPAddress(interface=parent1)
         factory.make_Interface(
-            INTERFACE_TYPE.BOND, parents=[parent1, parent2])
+            self.iftype, parents=[parent1, parent2])
         self.assertIsNone(reload_object(static_ip))
 
 

=== modified file 'src/maasserver/models/tests/test_interface.py'
--- src/maasserver/models/tests/test_interface.py	2016-03-12 03:19:19 +0000
+++ src/maasserver/models/tests/test_interface.py	2016-03-24 18:53:09 +0000
@@ -33,6 +33,7 @@
 )
 from maasserver.models.interface import (
     BondInterface,
+    BridgeInterface,
     Interface,
     PhysicalInterface,
     UnknownInterface,
@@ -682,7 +683,7 @@
         self.assertEqual({
             "mac_address": [
                 "This MAC address is already in use by %s." % (
-                    interface.node.hostname)]
+                    interface.get_log_string())]
             }, error.message_dict)
 
     def test_cannot_have_parents(self):
@@ -969,6 +970,125 @@
         self.assertFalse(reload_object(interface).enabled)
 
 
+class BridgeInterfaceTest(MAASServerTestCase):
+
+    def test_manager_returns_bridge_interfaces(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[parent1, parent2])
+        self.assertItemsEqual(
+            [interface], BridgeInterface.objects.all())
+
+    def test_get_node_returns_parent_node(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[parent1, parent2])
+        self.assertItemsEqual(
+            [interface], BridgeInterface.objects.all())
+        self.assertEqual(node, interface.get_node())
+
+    def test_removed_if_underlying_interfaces_gets_removed(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[parent1, parent2])
+        parent1.delete()
+        parent2.delete()
+        self.assertIsNone(reload_object(interface))
+
+    def test_requires_mac_address(self):
+        interface = BridgeInterface(
+            name=factory.make_name("bridge"), node=factory.make_Node())
+        error = self.assertRaises(ValidationError, interface.save)
+        self.assertEqual({
+            "mac_address": ["This field cannot be blank."]
+            }, error.message_dict)
+
+    def test_parent_interfaces_must_belong_to_same_node(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        error = self.assertRaises(
+            ValidationError, factory.make_Interface,
+            INTERFACE_TYPE.BRIDGE, parents=[parent1, parent2])
+        self.assertEqual({
+            "parents": ["Parent interfaces do not belong to the same node."]
+            }, error.message_dict)
+
+    def test_can_use_parents_mac_address(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        # Test is that no error is raised.
+        factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=parent1.mac_address,
+            parents=[parent1, parent2])
+
+    def test_can_use_unique_mac_address(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        # Test is that no error is raised.
+        factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=factory.make_mac_address(),
+            parents=[parent1, parent2])
+
+    def test_cannot_use_none_unique_mac_address(self):
+        node = factory.make_Node()
+        other_nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        # Test is that no error is raised.
+        error = self.assertRaises(
+            ValidationError, factory.make_Interface,
+            INTERFACE_TYPE.BRIDGE, mac_address=other_nic.mac_address,
+            parents=[parent1, parent2])
+        self.assertEqual({
+            "mac_address": [
+                "This MAC address is already in use by %s." % (
+                    other_nic.node.hostname)]
+            }, error.message_dict)
+
+    def test_node_is_set_to_parents_node(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=factory.make_mac_address(),
+            parents=[parent1, parent2])
+        self.assertEqual(interface.node, parent1.node)
+
+    def test_disable_one_parent_doesnt_disable_the_bridge(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=factory.make_mac_address(),
+            parents=[parent1, parent2])
+        parent1.enabled = False
+        parent1.save()
+        self.assertTrue(interface.is_enabled())
+        self.assertTrue(reload_object(interface).enabled)
+
+    def test_disable_all_parents_disables_the_bridge(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        parent2 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=factory.make_mac_address(),
+            parents=[parent1, parent2])
+        parent1.enabled = False
+        parent1.save()
+        parent2.enabled = False
+        parent2.save()
+        self.assertFalse(interface.is_enabled())
+        self.assertFalse(reload_object(interface).enabled)
+
+
 class UnknownInterfaceTest(MAASServerTestCase):
 
     def test_manager_returns_unknown_interfaces(self):
@@ -998,7 +1118,7 @@
         self.assertEqual({
             "mac_address": [
                 "This MAC address is already in use by %s." % (
-                    interface.node.hostname)]
+                    interface.get_log_string())]
             }, error.message_dict)
 
 

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2016-03-18 00:13:14 +0000
+++ src/maasserver/models/tests/test_node.py	2016-03-24 18:53:09 +0000
@@ -36,6 +36,7 @@
 from maasserver.models import (
     bmc as bmc_module,
     BondInterface,
+    BridgeInterface,
     Config,
     Device,
     Domain,
@@ -5310,6 +5311,53 @@
             [parent.name for parent in bond_interface.parents.all()],
             MatchesSetwise(Equals("eth0"), Equals("eth1")))
 
+    def test__bridge_with_existing_parents(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "eth1": {
+                "type": "physical",
+                "mac_address": eth1.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": factory.make_mac_address(),
+                "parents": ["eth0", "eth1"],
+                "links": [],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(rack.interface_set.count(), Equals(3))
+        bond_interface = BridgeInterface.objects.get(
+            node=rack, mac_address=interfaces["br0"]["mac_address"])
+        self.assertThat(
+            bond_interface, MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.BRIDGE,
+                name="br0",
+                mac_address=interfaces["br0"]["mac_address"],
+                enabled=True,
+                vlan=vlan,
+            ))
+        self.assertThat(
+            [parent.name for parent in bond_interface.parents.all()],
+            MatchesSetwise(Equals("eth0"), Equals("eth1")))
+
     def test__bond_updates_existing_bond(self):
         rack = self.create_empty_rack_controller()
         fabric = factory.make_Fabric()
@@ -5358,6 +5406,54 @@
             [parent.name for parent in bond0.parents.all()],
             Equals(["eth0"]))
 
+    def test__bridge_updates_existing_bridge(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        br0 = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, vlan=vlan, parents=[eth0, eth1], node=rack,
+            name="br0", mac_address=factory.make_mac_address())
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "eth1": {
+                "type": "physical",
+                "mac_address": eth1.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": factory.make_mac_address(),
+                "parents": ["eth0"],
+                "links": [],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(rack.interface_set.count(), Equals(3))
+        self.assertThat(
+            reload_object(br0), MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.BRIDGE,
+                name="br0",
+                mac_address=interfaces["br0"]["mac_address"],
+                enabled=True,
+                vlan=vlan,
+            ))
+        self.assertThat(
+            [parent.name for parent in br0.parents.all()],
+            Equals(["eth0"]))
+
     def test__bond_moves_bond_with_mac_address(self):
         rack = self.create_empty_rack_controller()
         fabric = factory.make_Fabric()
@@ -5411,6 +5507,59 @@
             [parent.name for parent in bond_to_move.parents.all()],
             MatchesSetwise(Equals("eth0"), Equals("eth1")))
 
+    def test__bridge_moves_bridge_with_mac_address(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        other_node = factory.make_Node()
+        other_nic = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=other_node)
+        bridge_mac_address = factory.make_mac_address()
+        bridge_to_move = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[other_nic], node=other_node,
+            mac_address=bridge_mac_address)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "eth1": {
+                "type": "physical",
+                "mac_address": eth1.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": bridge_mac_address,
+                "parents": ["eth0", "eth1"],
+                "links": [],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(rack.interface_set.count(), Equals(3))
+        self.assertThat(
+            reload_object(bridge_to_move), MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.BRIDGE,
+                name="br0",
+                mac_address=bridge_mac_address,
+                enabled=True,
+                node=rack,
+                vlan=vlan,
+            ))
+        self.assertThat(
+            [parent.name for parent in bridge_to_move.parents.all()],
+            MatchesSetwise(Equals("eth0"), Equals("eth1")))
+
     def test__bond_creates_link_updates_parent_vlan(self):
         rack = self.create_empty_rack_controller()
         fabric = factory.make_Fabric()
@@ -5483,6 +5632,78 @@
             [parent.name for parent in bond0.parents.all()],
             MatchesSetwise(Equals("eth0"), Equals("eth1")))
 
+    def test__bridge_creates_link_updates_parent_vlan(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        br0 = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[eth0, eth1], vlan=vlan)
+        other_fabric = factory.make_Fabric()
+        br0_vlan = other_fabric.get_default_vlan()
+        subnet = factory.make_Subnet(vlan=br0_vlan)
+        ip = factory.pick_ip_in_Subnet(subnet)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "eth1": {
+                "type": "physical",
+                "mac_address": eth1.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": br0.mac_address,
+                "parents": ["eth0", "eth1"],
+                "links": [{
+                    "mode": "static",
+                    "address": "%s/%d" % (
+                        str(ip), subnet.get_ipnetwork().prefixlen),
+                }],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(rack.interface_set.count(), Equals(3))
+        self.assertThat(
+            reload_object(eth0), MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.PHYSICAL,
+                name="eth0",
+                mac_address=eth0.mac_address,
+                enabled=True,
+                vlan=br0_vlan,
+            ))
+        self.assertThat(
+            reload_object(eth1), MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.PHYSICAL,
+                name="eth1",
+                mac_address=eth1.mac_address,
+                enabled=True,
+                vlan=br0_vlan,
+            ))
+        self.assertThat(
+            reload_object(br0), MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.BRIDGE,
+                name="br0",
+                mac_address=br0.mac_address,
+                enabled=True,
+                node=rack,
+                vlan=br0_vlan,
+            ))
+        self.assertThat(
+            [parent.name for parent in br0.parents.all()],
+            MatchesSetwise(Equals("eth0"), Equals("eth1")))
+
     def test__removes_missing_interfaces(self):
         rack = self.create_empty_rack_controller()
         fabric = factory.make_Fabric()
@@ -5529,6 +5750,37 @@
         self.assertThat(reload_object(eth1), Is(None))
         self.assertThat(reload_object(bond0), Not(Is(None)))
 
+    def test__removes_one_bridge_parent(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        br0 = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[eth0, eth1], vlan=vlan)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": br0.mac_address,
+                "parents": ["eth0"],
+                "links": [],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(reload_object(eth0), Not(Is(None)))
+        self.assertThat(reload_object(eth1), Is(None))
+        self.assertThat(reload_object(br0), Not(Is(None)))
+
     def test__removes_one_bond_and_one_parent(self):
         rack = self.create_empty_rack_controller()
         fabric = factory.make_Fabric()
@@ -5553,7 +5805,31 @@
         self.assertThat(reload_object(eth1), Is(None))
         self.assertThat(reload_object(bond0), Is(None))
 
-    def test__all_new_complex_interfaces(self):
+    def test__removes_one_bridge_and_one_parent(self):
+        rack = self.create_empty_rack_controller()
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        eth0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        eth1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack, vlan=vlan)
+        br0 = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, parents=[eth0, eth1], vlan=vlan)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": eth0.mac_address,
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+        }
+        rack.update_interfaces(interfaces)
+        self.assertThat(reload_object(eth0), Not(Is(None)))
+        self.assertThat(reload_object(eth1), Is(None))
+        self.assertThat(reload_object(br0), Is(None))
+
+    def test__all_new_bond_with_vlan(self):
         rack = self.create_empty_rack_controller()
         bond0_fabric = factory.make_Fabric()
         bond0_untagged = bond0_fabric.get_default_vlan()
@@ -5664,6 +5940,117 @@
                 subnet=bond0_vlan_subnet,
             ))
 
+    def test__all_new_bridge_with_vlan(self):
+        rack = self.create_empty_rack_controller()
+        br0_fabric = factory.make_Fabric()
+        br0_untagged = br0_fabric.get_default_vlan()
+        br0_subnet = factory.make_Subnet(vlan=br0_untagged)
+        br0_ip = factory.pick_ip_in_Subnet(br0_subnet)
+        br0_vlan = factory.make_VLAN(fabric=br0_fabric)
+        br0_vlan_subnet = factory.make_Subnet(vlan=br0_vlan)
+        br0_vlan_ip = factory.pick_ip_in_Subnet(br0_vlan_subnet)
+        interfaces = {
+            "eth0": {
+                "type": "physical",
+                "mac_address": factory.make_mac_address(),
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "eth1": {
+                "type": "physical",
+                "mac_address": factory.make_mac_address(),
+                "parents": [],
+                "links": [],
+                "enabled": True,
+            },
+            "br0": {
+                "type": "bridge",
+                "mac_address": factory.make_mac_address(),
+                "parents": ["eth0", "eth1"],
+                "links": [{
+                    "mode": "static",
+                    "address": "%s/%d" % (
+                        str(br0_ip), br0_subnet.get_ipnetwork().prefixlen),
+                }],
+                "enabled": True,
+            },
+        }
+        interfaces["br0.%d" % br0_vlan.vid] = {
+            "type": "vlan",
+            "parents": ["br0"],
+            "links": [{
+                "mode": "static",
+                "address": "%s/%d" % (
+                    str(br0_vlan_ip),
+                    br0_vlan_subnet.get_ipnetwork().prefixlen),
+            }],
+            "vid": br0_vlan.vid,
+            "enabled": True,
+        }
+        rack.update_interfaces(interfaces)
+        eth0 = PhysicalInterface.objects.get(
+            node=rack, mac_address=interfaces["eth0"]["mac_address"])
+        self.assertThat(
+            eth0, MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.PHYSICAL,
+                name="eth0",
+                mac_address=interfaces["eth0"]["mac_address"],
+                enabled=True,
+                vlan=br0_untagged,
+            ))
+        eth1 = PhysicalInterface.objects.get(
+            node=rack, mac_address=interfaces["eth1"]["mac_address"])
+        self.assertThat(
+            eth1, MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.PHYSICAL,
+                name="eth1",
+                mac_address=interfaces["eth1"]["mac_address"],
+                enabled=True,
+                vlan=br0_untagged,
+            ))
+        br0 = BridgeInterface.objects.get(
+            node=rack, mac_address=interfaces["br0"]["mac_address"])
+        self.assertThat(
+            br0, MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.BRIDGE,
+                name="br0",
+                mac_address=interfaces["br0"]["mac_address"],
+                enabled=True,
+                vlan=br0_untagged,
+            ))
+        self.assertThat(
+            [parent.name for parent in br0.parents.all()],
+            MatchesSetwise(Equals("eth0"), Equals("eth1")))
+        br0_addresses = list(br0.ip_addresses.all())
+        self.assertThat(br0_addresses, HasLength(1))
+        self.assertThat(
+            br0_addresses[0], MatchesStructure.byEquality(
+                alloc_type=IPADDRESS_TYPE.STICKY,
+                ip=br0_ip,
+                subnet=br0_subnet,
+            ))
+        br0_vlan_nic = VLANInterface.objects.get(
+            node=rack, vlan=br0_vlan)
+        self.assertThat(
+            br0_vlan_nic, MatchesStructure.byEquality(
+                type=INTERFACE_TYPE.VLAN,
+                name="br0.%d" % br0_vlan.vid,
+                enabled=True,
+                vlan=br0_vlan,
+            ))
+        self.assertThat(
+            [parent.name for parent in br0_vlan_nic.parents.all()],
+            Equals(["br0"]))
+        br0_vlan_nic_addresses = list(br0_vlan_nic.ip_addresses.all())
+        self.assertThat(br0_vlan_nic_addresses, HasLength(1))
+        self.assertThat(
+            br0_vlan_nic_addresses[0], MatchesStructure.byEquality(
+                alloc_type=IPADDRESS_TYPE.STICKY,
+                ip=br0_vlan_ip,
+                subnet=br0_vlan_subnet,
+            ))
+
 
 class TestRackController(MAASServerTestCase):
 

=== modified file 'src/maasserver/static/js/angular/controllers/node_details_networking.js'
--- src/maasserver/static/js/angular/controllers/node_details_networking.js	2016-03-16 20:41:33 +0000
+++ src/maasserver/static/js/angular/controllers/node_details_networking.js	2016-03-24 18:53:09 +0000
@@ -36,17 +36,17 @@
 // Filter that is specific to the NodeNetworkingController. Filters the
 // list of interfaces to not include the current parent interfaces being
 // bonded together.
-angular.module('MAAS').filter('removeBondParents', function() {
-    return function(interfaces, bondInterface) {
-        if(!angular.isObject(bondInterface) ||
-            !angular.isArray(bondInterface.parents)) {
+angular.module('MAAS').filter('removeInterfaceParents', function() {
+    return function(interfaces, childInterface) {
+        if(!angular.isObject(childInterface) ||
+            !angular.isArray(childInterface.parents)) {
             return interfaces;
         }
         var filtered = [];
         angular.forEach(interfaces, function(nic) {
             var i, parent, found = false;
-            for(i = 0; i < bondInterface.parents.length; i++) {
-                parent = bondInterface.parents[i];
+            for(i = 0; i < childInterface.parents.length; i++) {
+                parent = childInterface.parents[i];
                 if(parent.id === nic.id && parent.link_id === nic.link_id) {
                     found = true;
                     break;
@@ -130,12 +130,14 @@
         var INTERFACE_TYPE = {
             PHYSICAL: "physical",
             BOND: "bond",
+            BRIDGE: "bridge",
             VLAN: "vlan",
             ALIAS: "alias"
         };
         var INTERFACE_TYPE_TEXTS = {
             "physical": "Physical",
             "bond": "Bond",
+            "bridge": "Bridge",
             "vlan": "VLAN",
             "alias": "Alias"
         };
@@ -235,11 +237,12 @@
                 // interface with a bond child can only have one child.
                 if(nic.children.length === 1) {
                     var child = $scope.originalInterfaces[nic.children[0]];
-                    if(child.type === INTERFACE_TYPE.BOND) {
-                        // This parent now has a bond for a child, if this was
-                        // the focusInterface then the focus needs to be
-                        // removed. We only need to check the "id" not the
-                        // "link_id", because if this interface did have
+                    if(child.type === INTERFACE_TYPE.BOND ||
+                       child.type === INTERFACE_TYPE.BRIDGE) {
+                        // This parent now has a bond or bridge for a child.
+                        // If this was the focusInterface, then the focus needs
+                        // to be removed. We only need to check the "id" (not
+                        // the "link_id"), because if this interface did have
                         // aliases they have now been removed.
                         if(angular.isObject($scope.focusInterface) &&
                             $scope.focusInterface.id === nic.id) {
@@ -249,9 +252,10 @@
                     }
                 }
 
-                // When the interface is a bond, place the children as members
-                // for that interface.
-                if(nic.type === INTERFACE_TYPE.BOND) {
+                // When the interface is a bond or a bridge, place the children
+                // as members for that interface.
+                if(nic.type === INTERFACE_TYPE.BOND ||
+                   nic.type === INTERFACE_TYPE.BRIDGE) {
                     nic.members = [];
                     angular.forEach(nic.parents, function(parent) {
                         nic.members.push(
@@ -528,7 +532,8 @@
 
             if(nic.is_boot && nic.type !== INTERFACE_TYPE.ALIAS) {
                 return true;
-            } else if(nic.type === INTERFACE_TYPE.BOND) {
+            } else if(nic.type === INTERFACE_TYPE.BOND ||
+                      nic.type === INTERFACE_TYPE.BRIDGE) {
                 var i;
                 for(i = 0; i < nic.members.length; i++) {
                     if(nic.members[i].is_boot) {

=== modified file 'src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js'
--- src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2016-03-16 20:41:33 +0000
+++ src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2016-03-24 18:53:09 +0000
@@ -77,15 +77,15 @@
 });
 
 
-describe("removeBondParents", function() {
+describe("removeInterfaceParents", function() {
 
     // Load the MAAS module.
     beforeEach(module("MAAS"));
 
-    // Load the removeBondParents.
-    var removeBondParents;
+    // Load the removeInterfaceParents.
+    var removeInterfaceParents;
     beforeEach(inject(function($filter) {
-        removeBondParents = $filter("removeBondParents");
+        removeInterfaceParents = $filter("removeInterfaceParents");
     }));
 
     it("returns empty if undefined bondInterface", function() {
@@ -97,7 +97,7 @@
             };
             interfaces.push(nic);
         }
-        expect(removeBondParents(interfaces)).toEqual(interfaces);
+        expect(removeInterfaceParents(interfaces)).toEqual(interfaces);
     });
 
     it("removes parents from interfaces", function() {
@@ -120,7 +120,7 @@
         var bondInterface = {
             parents: interfaces
         };
-        expect(removeBondParents(interfaces, bondInterface)).toEqual([]);
+        expect(removeInterfaceParents(interfaces, bondInterface)).toEqual([]);
     });
 });
 
@@ -510,6 +510,49 @@
             }]);
         });
 
+        it("removes bridge parents and places them as members", function() {
+            var parent1 = {
+                id: 0,
+                name: "eth0",
+                type: "physical",
+                parents: [],
+                children: [2],
+                links: []
+            };
+            var parent2 = {
+                id: 1,
+                name: "eth1",
+                type: "physical",
+                parents: [],
+                children: [2],
+                links: []
+            };
+            var bridge = {
+                id: 2,
+                name: "br0",
+                type: "bridge",
+                parents: [0, 1],
+                children: [],
+                links: []
+            };
+            node.interfaces = [parent1, parent2, bridge];
+            updateInterfaces();
+            expect($scope.interfaces).toEqual([{
+                id: 2,
+                name: "br0",
+                type: "bridge",
+                parents: [0, 1],
+                children: [],
+                links: [],
+                members: [parent1, parent2],
+                vlan: null,
+                link_id: -1,
+                subnet: null,
+                mode: "link_up",
+                ip_address: ""
+            }]);
+        });
+
         it("clears focusInterface if parent is now in a bond", function() {
             var parent1 = {
                 id: 0,
@@ -544,6 +587,40 @@
             expect($scope.focusInterface).toBeNull();
         });
 
+       it("clears focusInterface if parent is now in a bridge", function() {
+            var parent1 = {
+                id: 0,
+                name: "eth0",
+                type: "physical",
+                parents: [],
+                children: [2],
+                links: []
+            };
+            var parent2 = {
+                id: 1,
+                name: "eth1",
+                type: "physical",
+                parents: [],
+                children: [2],
+                links: []
+            };
+            var bridge = {
+                id: 2,
+                name: "br0",
+                type: "bridge",
+                parents: [0, 1],
+                children: [],
+                links: []
+            };
+            node.interfaces = [parent1, parent2, bridge];
+            $scope.focusInterface = {
+                id: 0,
+                link_id: -1
+            };
+            updateInterfaces();
+            expect($scope.focusInterface).toBeNull();
+        });
+
         it("sets vlan and fabric on interface", function() {
             var fabric = {
                 id: 0

=== modified file 'src/maasserver/static/partials/node-details.html'
--- src/maasserver/static/partials/node-details.html	2016-03-24 11:47:04 +0000
+++ src/maasserver/static/partials/node-details.html	2016-03-24 18:53:09 +0000
@@ -543,7 +543,7 @@
                             <main class="table__body" data-selected-rows>
                                 <div class="table__row"
                                     data-ng-class="{ active: isInterfaceSelected(interface), disabled: isDisabled(), noEdit: cannotEditInterface(interface) }"
-                                    data-ng-repeat="interface in interfaces | removeBondParents:newBondInterface">
+                                    data-ng-repeat="interface in interfaces | removeInterfaceParents:newBondInterface">
                                     <div class="table__data table-col--3">
                                         <span data-ng-hide="isAllNetworkingDisabled()">
                                             <input class="checkbox" type="checkbox" id="{$ getUniqueKey(interface) $}"

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2016-03-24 04:11:19 +0000
+++ src/maasserver/testing/factory.py	2016-03-24 18:53:09 +0000
@@ -850,6 +850,8 @@
                 name = self.make_name('eth', sep=':')
             elif iftype == INTERFACE_TYPE.BOND:
                 name = self.make_name('bond')
+            elif iftype == INTERFACE_TYPE.BRIDGE:
+                name = self.make_name('br')
             elif iftype == INTERFACE_TYPE.UNKNOWN:
                 name = self.make_name('eth')
             elif iftype == INTERFACE_TYPE.VLAN:
@@ -875,6 +877,7 @@
                 iftype in [
                     INTERFACE_TYPE.PHYSICAL,
                     INTERFACE_TYPE.BOND,
+                    INTERFACE_TYPE.BRIDGE,
                     INTERFACE_TYPE.UNKNOWN]):
             mac_address = self.make_MAC()
         if node is None and iftype == INTERFACE_TYPE.PHYSICAL:

=== modified file 'src/maasserver/tests/test_forms_interface.py'
--- src/maasserver/tests/test_forms_interface.py	2016-03-07 23:20:52 +0000
+++ src/maasserver/tests/test_forms_interface.py	2016-03-24 18:53:09 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for Interface forms."""
@@ -17,6 +17,7 @@
     BOND_MODE_CHOICES,
     BOND_XMIT_HASH_POLICY_CHOICES,
     BondInterfaceForm,
+    BridgeInterfaceForm,
     ControllerInterfaceForm,
     InterfaceForm,
     PhysicalInterfaceForm,
@@ -675,7 +676,7 @@
         self.assertFalse(form.is_valid(), form.errors)
         self.assertItemsEqual(['parents', 'mac_address'], form.errors.keys())
         self.assertIn(
-            "A Bond interface must have one or more parents.",
+            "A bond interface must have one or more parents.",
             form.errors['parents'][0])
 
     def test__rejects_when_vlan_not_untagged(self):
@@ -713,7 +714,7 @@
             })
         self.assertFalse(form.is_valid(), form.errors)
         self.assertIn(
-            "eth0, eth1 is already in-use by another interface.",
+            "Interfaces already in-use: eth0, eth1.",
             form.errors['parents'][0])
 
     def test__rejects_when_parents_not_in_same_vlan(self):
@@ -965,3 +966,189 @@
             "bond_lacp_rate": new_bond_lacp_rate,
             "bond_xmit_hash_policy": new_bond_xmit_hash_policy,
             }, interface.params)
+
+
+class BridgeInterfaceFormTest(MAASServerTestCase):
+
+    def test__creates_bridge_interface(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node, vlan=parent1.vlan)
+        interface_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            node=parent1.node,
+            data={
+                'name': interface_name,
+                'parents': [parent1.id, parent2.id],
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertThat(
+            interface,
+            MatchesStructure.byEquality(
+                name=interface_name, type=INTERFACE_TYPE.BRIDGE))
+        self.assertIn(
+            interface.mac_address, [parent1.mac_address, parent2.mac_address])
+        self.assertItemsEqual([parent1, parent2], interface.parents.all())
+
+    def test__create_removes_parent_links_and_sets_link_up_on_bridge(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent1.ensure_link_up()
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node, vlan=parent1.vlan)
+        parent2.ensure_link_up()
+        interface_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            node=parent1.node,
+            data={
+                'name': interface_name,
+                'parents': [parent1.id, parent2.id],
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertEqual(
+            0,
+            parent1.ip_addresses.exclude(
+                alloc_type=IPADDRESS_TYPE.DISCOVERED).count())
+        self.assertEqual(
+            0,
+            parent2.ip_addresses.exclude(
+                alloc_type=IPADDRESS_TYPE.DISCOVERED).count())
+        self.assertIsNotNone(
+            interface.ip_addresses.filter(alloc_type=IPADDRESS_TYPE.STICKY))
+
+    def test__creates_bridge_interface_with_parent_mac_address(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node, vlan=parent1.vlan)
+        interface_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            node=parent1.node,
+            data={
+                'name': interface_name,
+                'parents': [parent1.id, parent2.id],
+                'mac_address': parent1.mac_address,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertThat(
+            interface,
+            MatchesStructure.byEquality(
+                name=interface_name, mac_address=parent1.mac_address,
+                type=INTERFACE_TYPE.BRIDGE))
+        self.assertItemsEqual([parent1, parent2], interface.parents.all())
+
+    def test__rejects_no_parents(self):
+        interface_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            node=factory.make_Node(),
+            data={
+                'name': interface_name,
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertItemsEqual(['parents', 'mac_address'], form.errors.keys())
+        self.assertIn(
+            "A bridge interface must have one or more parents.",
+            form.errors['parents'][0])
+
+    def test__rejects_when_parents_already_have_children(self):
+        node = factory.make_Node()
+        parent1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node, name="eth0")
+        factory.make_Interface(INTERFACE_TYPE.VLAN, parents=[parent1])
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node, name="eth1", vlan=parent1.vlan)
+        factory.make_Interface(INTERFACE_TYPE.VLAN, parents=[parent2])
+        interface_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            node=node,
+            data={
+                'name': interface_name,
+                'parents': [parent1.id, parent2.id]
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertIn(
+            "Interfaces already in-use: eth0, eth1.",
+            form.errors['parents'][0])
+
+    def test__edits_interface(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node, vlan=parent1.vlan)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE,
+            parents=[parent1, parent2])
+        new_fabric = factory.make_Fabric()
+        new_vlan = new_fabric.get_default_vlan()
+        new_name = factory.make_name()
+        new_parent = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node, vlan=parent1.vlan)
+        form = BridgeInterfaceForm(
+            instance=interface,
+            data={
+                'vlan': new_vlan.id,
+                'name': new_name,
+                'parents': [parent1.id, parent2.id, new_parent.id],
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertThat(
+            interface,
+            MatchesStructure.byEquality(
+                mac_address=interface.mac_address, name=new_name,
+                vlan=new_vlan, type=INTERFACE_TYPE.BRIDGE))
+        self.assertItemsEqual(
+            [parent1, parent2, new_parent], interface.parents.all())
+
+    def test__edits_interface_removes_parents(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node)
+        parent3 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE,
+            parents=[parent1, parent2, parent3])
+        new_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            instance=interface,
+            data={
+                'name': new_name,
+                'parents': [parent1.id, parent2.id],
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertThat(
+            interface,
+            MatchesStructure.byEquality(
+                mac_address=interface.mac_address, name=new_name,
+                type=INTERFACE_TYPE.BRIDGE))
+        self.assertItemsEqual(
+            [parent1, parent2], interface.parents.all())
+
+    def test__edits_interface_updates_mac_address_when_parent_removed(self):
+        parent1 = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        parent2 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node)
+        parent3 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent1.node)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.BRIDGE, mac_address=parent3.mac_address,
+            parents=[parent1, parent2, parent3])
+        new_name = factory.make_name()
+        form = BridgeInterfaceForm(
+            instance=interface,
+            data={
+                'name': new_name,
+                'parents': [parent1.id, parent2.id],
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        self.assertThat(
+            interface,
+            MatchesStructure.byEquality(
+                name=new_name, type=INTERFACE_TYPE.BRIDGE))
+        self.assertItemsEqual(
+            [parent1, parent2], interface.parents.all())
+        self.assertIn(
+            interface.mac_address, [parent1.mac_address, parent2.mac_address])

=== modified file 'src/provisioningserver/utils/__init__.py'
--- src/provisioningserver/utils/__init__.py	2016-03-07 20:18:45 +0000
+++ src/provisioningserver/utils/__init__.py	2016-03-24 18:53:09 +0000
@@ -343,17 +343,14 @@
         making it impossible to resolve their relative ordering.
     """
     empty = frozenset()
-
     # Copy data and discard self-referential dependencies.
     data = {thing: set(deps) for thing, deps in data.items()}
     for thing, deps in data.items():
         deps.discard(thing)
-
     # Find ghost dependencies and add them as "things".
     ghosts = reduce(set.union, data.values(), set()).difference(data)
     for ghost in ghosts:
         data[ghost] = empty
-
     # Skim batches off the top until we're done.
     while len(data) != 0:
         batch = {thing for thing, deps in data.items() if deps == empty}

=== modified file 'src/provisioningserver/utils/ipaddr.py'
--- src/provisioningserver/utils/ipaddr.py	2016-03-08 18:50:36 +0000
+++ src/provisioningserver/utils/ipaddr.py	2016-03-24 18:53:09 +0000
@@ -342,15 +342,12 @@
     Annotates the given dictionary to update it with driver information
     (if found) for each interface.
 
-    Deletes bond interfaces if they are not configured.
-
     :param interfaces: interfaces dictionary from `parse_ip_addr()`.
     :param proc_net: path to /proc/net
     :param sys_class_net: path to /sys/class/net
     """
     interfaces = annotate_with_proc_net_bonding_original_macs(
         interfaces, proc_net=proc_net)
-    bogus_interfaces = []
     for name in interfaces:
         iface = interfaces[name]
         iftype = get_interface_type(
@@ -359,20 +356,12 @@
         if iftype == 'ethernet.bond':
             bond_parents = get_bonded_interfaces(
                 name, sys_class_net=sys_class_net)
-            if len(bond_parents) > 0:
-                iface['bonded_interfaces'] = bond_parents
-            else:
-                # If we found a bond interface with no parents, just pretend
-                # it doesn't exist. The MAAS model assumes bonds must have
-                # backing interfaces.
-                bogus_interfaces.append(name)
+            iface['bonded_interfaces'] = bond_parents
         elif iftype == 'ethernet.vlan':
             iface['vid'] = get_vid_from_ifname(name)
         elif iftype == 'ethernet.bridge':
             iface['bridged_interfaces'] = get_bridged_interfaces(
                 name, sys_class_net=sys_class_net)
-    for name in bogus_interfaces:
-        del interfaces[name]
     return interfaces
 
 

=== modified file 'src/provisioningserver/utils/network.py'
--- src/provisioningserver/utils/network.py	2016-03-17 14:17:57 +0000
+++ src/provisioningserver/utils/network.py	2016-03-24 18:53:09 +0000
@@ -646,6 +646,12 @@
             iface_type = "vlan"
             parents.append(name.split(".", 1)[0])
             vid = ipaddr["vid"]
+        elif ipaddr["type"] == "ethernet.bridge":
+            iface_type = "bridge"
+            mac_address = ipaddr["mac"]
+            for bridge_nic in ipaddr["bridged_interfaces"]:
+                if bridge_nic in interfaces or bridge_nic in ipaddr_info:
+                    parents.append(bridge_nic)
         else:
             mac_address = ipaddr["mac"]
 

=== modified file 'src/provisioningserver/utils/tests/test_ipaddr.py'
--- src/provisioningserver/utils/tests/test_ipaddr.py	2016-03-08 18:50:36 +0000
+++ src/provisioningserver/utils/tests/test_ipaddr.py	2016-03-24 18:53:09 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Test parser for 'ip addr show'."""
@@ -34,7 +34,6 @@
 from testtools.matchers import (
     Contains,
     Equals,
-    HasLength,
     Not,
 )
 
@@ -507,27 +506,6 @@
             elif iface['type'] == 'ethernet.bridge':
                 self.expectThat(iface, Contains('bridged_interfaces'))
 
-    def test__ignores_bond_interfaces_with_no_parents(self):
-        interfaces = {
-            'eth0': {},
-            'eth1': {},
-            'bond0': {},
-            'bond1': {},
-        }
-        self.createEthernetInterface('eth0', is_physical=True)
-        self.createEthernetInterface('eth1', is_physical=True)
-        self.createEthernetInterface(
-            'bond0', is_bond=True, bonded_interfaces=['eth0, eth1'])
-        self.createEthernetInterface(
-            'bond1', is_bond=True, bonded_interfaces=[])
-        interfaces = annotate_with_driver_information(
-            interfaces, sys_class_net=self.tmp_sys_net,
-            proc_net=self.tmp_proc_net)
-        self.expectThat(interfaces, HasLength(3))
-        self.expectThat(interfaces, Contains('eth0'))
-        self.expectThat(interfaces, Contains('eth1'))
-        self.expectThat(interfaces, Contains('bond0'))
-
     def test__finds_bond_members_original_mac_addresses(self):
         testdata = dedent("""\
             Ethernet Channel Bonding Driver: v3.7.1 (April 27, 2011)

=== modified file 'src/provisioningserver/utils/tests/test_network.py'
--- src/provisioningserver/utils/tests/test_network.py	2016-03-17 14:17:57 +0000
+++ src/provisioningserver/utils/tests/test_network.py	2016-03-24 18:53:09 +0000
@@ -1058,6 +1058,7 @@
             },
             "br0": {
                 "type": "ethernet.bridge",
+                "bridged_interfaces": ["eth0"],
                 "mac": factory.make_mac_address(),
                 "flags": ["UP"],
                 "inet": ["192.168.124.2/24"],
@@ -1145,10 +1146,10 @@
                 "source": Equals("ipaddr"),
             }),
             "br0": MatchesDict({
-                "type": Equals("physical"),
+                "type": Equals("bridge"),
                 "mac_address": Equals(ip_addr["br0"]["mac"]),
                 "enabled": Is(True),
-                "parents": Equals([]),
+                "parents": Equals(["eth0"]),
                 "links": Equals([{
                     "mode": "static",
                     "address": "192.168.124.2/24",