diff --git a/etc/dhcp_agent.ini b/etc/dhcp_agent.ini
old mode 100644
new mode 100755
index 9836d35..6665b89
--- a/etc/dhcp_agent.ini
+++ b/etc/dhcp_agent.ini
@@ -86,3 +86,16 @@
 # Timeout for ovs-vsctl commands.
 # If the timeout expires, ovs commands will fail with ALARMCLOCK error.
 # ovs_vsctl_timeout = 10
+
+# Name of a bridge through which dhcp relay agent will connect to external
+# network in which DHCP server resides
+# dhcp_relay_bridge = br-mgmt
+
+# Path to dhcrelay agent executable
+# dhcrelay_path = /usr/local/dhcp-4.3.0/sbin/dhcrelay
+
+# Path to dhclient executable
+# dhcrelay_path = /usr/local/dhcp-4.3.0/sbin/dhclient
+
+# Relay interface name length
+# interface_dev_name_len = 10
diff --git a/etc/neutron.conf b/etc/neutron.conf
index 7fa8795..45e0129 100644
--- a/etc/neutron.conf
+++ b/etc/neutron.conf
@@ -75,6 +75,9 @@ lock_path = $state_path/lock
 # Paste configuration file
 # api_paste_config = api-paste.ini
 
+# IPAM driver
+# ipam_driver = neutron.ipam.drivers.neutron_ipam.NeutronIPAM
+
 # The strategy to be used for auth.
 # Supported values are 'keystone'(default), 'noauth'.
 # auth_strategy = keystone
diff --git a/etc/neutron/rootwrap.d/dhcp.filters b/etc/neutron/rootwrap.d/dhcp.filters
index 7c11d70..8a8e07d 100644
--- a/etc/neutron/rootwrap.d/dhcp.filters
+++ b/etc/neutron/rootwrap.d/dhcp.filters
@@ -9,7 +9,8 @@
 [Filters]
 
 # dhcp-agent
-dnsmasq: EnvFilter, dnsmasq, root, NEUTRON_NETWORK_ID=
+dnsmasq: EnvFilter, env, root, NEUTRON_NETWORK_ID=, dnsmasq
+
 # dhcp-agent uses kill as well, that's handled by the generic KillFilter
 # it looks like these are the only signals needed, per
 # neutron/agent/linux/dhcp.py
@@ -20,6 +21,9 @@ ovs-vsctl: CommandFilter, ovs-vsctl, root
 ivs-ctl: CommandFilter, ivs-ctl, root
 mm-ctl: CommandFilter, mm-ctl, root
 dhcp_release: CommandFilter, dhcp_release, root
+dhcrelay: CommandFilter, /usr/local/dhcp-4.3.0/sbin/dhcrelay, root
+dhclient: CommandFilter, /usr/local/dhcp-4.3.0/sbin/dhclient, root
+kill: CommandFilter, kill, root
 
 # metadata proxy
 metadata_proxy: CommandFilter, neutron-ns-metadata-proxy, root
diff --git a/neutron/agent/dhcp_agent.py b/neutron/agent/dhcp_agent.py
index 19b8e9a..2c24634 100644
--- a/neutron/agent/dhcp_agent.py
+++ b/neutron/agent/dhcp_agent.py
@@ -23,6 +23,7 @@ from oslo.config import cfg
 
 from neutron.agent.common import config
 from neutron.agent.linux import dhcp
+from neutron.agent.linux import dhcp_relay
 from neutron.agent.linux import external_process
 from neutron.agent.linux import interface
 from neutron.agent.linux import ovs_lib  # noqa
@@ -616,6 +617,7 @@ def register_options():
     config.register_agent_state_opts_helper(cfg.CONF)
     config.register_root_helper(cfg.CONF)
     cfg.CONF.register_opts(dhcp.OPTS)
+    cfg.CONF.register_opts(dhcp_relay.OPTS)
     cfg.CONF.register_opts(interface.OPTS)
 
 
diff --git a/neutron/agent/linux/dhcp_relay.py b/neutron/agent/linux/dhcp_relay.py
new file mode 100755
index 0000000..17b39eb
--- /dev/null
+++ b/neutron/agent/linux/dhcp_relay.py
@@ -0,0 +1,474 @@
+# Copyright 2014 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import os
+import random
+
+import netaddr
+from oslo.config import cfg
+
+from neutron.agent.linux import dhcp
+from neutron.agent.linux import ip_lib
+from neutron.agent.linux import utils
+from neutron.common import exceptions as exc
+from neutron.common import ipv6_utils
+from neutron.openstack.common import log as logging
+from neutron.openstack.common import uuidutils
+
+LOG = logging.getLogger(__name__)
+
+OPTS = [
+    cfg.ListOpt('external_dhcp_servers',
+                default=None,
+                help=_('IP addresses of DHCP servers to relay to.')),
+    cfg.ListOpt('external_dns_servers',
+                default=None,
+                help=_('IP addresses of DNS servers to relay to.')),
+    cfg.StrOpt('dhcp_relay_bridge',
+               default=None,
+               help=_('Name of a bridge through which ipam proxy agent will'
+                      ' connect to external network in which DHCP and DNS'
+                      ' server resides.')),
+    cfg.StrOpt('dhclient_path',
+               default='dhclient',
+               help=_('Path to dhclient executable.')),
+    cfg.StrOpt('dhcrelay_path',
+               default='dhcrelay',
+               help=_('Path to dhcrelay executable.')),
+    cfg.BoolOpt('use_link_selection_option',
+                default=True,
+                help=_('Run dhcrelay with -o flag.')),
+    cfg.BoolOpt('use_ipv6_unicast_requests',
+                default=True,
+                help=_('Run dhcrelay -u server1%iface2 -u server2%iface2')),
+    cfg.StrOpt('dhcp_relay_management_network',
+               default=None,
+               help=_("CIDR for the management network served by "
+                      "Infoblox DHCP member")),
+    cfg.BoolOpt('enable_ipv6_relay',
+                default=True,
+                help=_('Enable/Disable DHCP/DNS relay for IPv6'))
+]
+
+
+MGMT_INTERFACE_IP_ATTR = 'mgmt_iface_ip'
+
+
+def _generate_mac_address():
+    mac = [0x00, 0x16, 0x3e,
+           random.randint(0x00, 0x7f),
+           random.randint(0x00, 0xff),
+           random.randint(0x00, 0xff)]
+    return ':'.join(map(lambda x: "%02x" % x, mac))
+
+
+class DhcpDnsProxy(dhcp.DhcpLocalProcess):
+    """DHCP & DNS relay agent class."""
+
+    MINIMUM_VERSION = 0
+    DEV_NAME_LEN = 14
+    RELAY_DEV_NAME_PREFIX = 'trel'
+    NEUTRON_NETWORK_ID_KEY = 'NEUTRON_NETWORK_ID'
+    DHCPv4 = 4
+    DHCPv6 = 6
+
+    def _calc_dev_name_len(self):
+        if self.conf.interface_dev_name_len:
+            return self.conf.interface_dev_name_len
+        else:
+            return self.DEV_NAME_LEN
+
+    def _enable_dns_dhcp(self):
+        """check if there is a subnet within the network with dhcp enabled."""
+        for subnet in self.network.subnets:
+            if subnet.enable_dhcp:
+                return True
+        return False
+
+    def __init__(self, conf, network, root_helper='sudo',
+                 version=None, plugin=None):
+        super(DhcpDnsProxy, self).__init__(conf, network, root_helper,
+                                           version, plugin)
+
+        external_dhcp_servers = self._get_relay_ips('external_dhcp_servers')
+        external_dns_servers = self._get_relay_ips('external_dns_servers')
+        required_options = {'dhcp_relay_bridge': self.conf.dhcp_relay_bridge,
+                            'external_dhcp_servers': external_dhcp_servers,
+                            'external_dns_servers': external_dns_servers}
+
+        for option_name, option in required_options.iteritems():
+            if not option:
+                LOG.error(_('You must specify an %(opt)s option in config'),
+                          {'opt': option_name})
+                raise exc.InvalidConfigurationOption(
+                    opt_name=option_name,
+                    opt_value=option
+                )
+
+        self.dev_name_len = self._calc_dev_name_len()
+        self.device_manager = DnsDhcpProxyDeviceManager(
+            conf, root_helper, plugin)
+
+    @classmethod
+    def check_version(cls):
+        return 0
+
+    @classmethod
+    def get_isolated_subnets(cls, network):
+        """Returns a dict indicating whether or not a subnet is isolated"""
+        if hasattr(dhcp.Dnsmasq, 'get_isolated_subnets') \
+               and callable(getattr(dhcp.Dnsmasq, 'get_isolated_subnets')):
+            dhcp.Dnsmasq.get_isolated_subnets(network)
+
+    @classmethod
+    def should_enable_metadata(cls, conf, network):
+        """True if the metadata-proxy should be enabled for the network."""
+        if hasattr(dhcp.Dnsmasq, 'should_enable_metadata') \
+               and callable(getattr(dhcp.Dnsmasq, 'should_enable_metadata')):
+            dhcp.Dnsmasq.should_enable_metadata(conf, network)
+        else:
+            conf.enable_isolated_metadata
+
+    @classmethod
+    def existing_dhcp_networks(cls, conf, root_helper):
+        """Return a list of existing networks ids that we have configs for."""
+        confs_dir = os.path.abspath(os.path.normpath(conf.dhcp_confs))
+        return [
+            c for c in os.listdir(confs_dir)
+            if uuidutils.is_uuid_like(c)
+        ]
+
+    def release_lease(self, mac_address, removed_ips):
+        """Release a DHCP lease."""
+        pass
+
+    def reload_allocations(self):
+        """Force the DHCP server to reload the assignment database."""
+        pass
+
+    @property
+    def ipv6_enabled(self):
+        return self.conf.enable_ipv6_relay and ipv6_utils.is_enabled()
+
+    def get_dhcp_pid(self, version):
+        """Last known pid for the dhcrelay process spawned for this network."""
+        return self._get_value_from_conf_file('dhcp%s_pid' % version, int)
+
+    def get_dns_pid(self):
+        """Last known pid for the dnsmasq process spawned for this network."""
+        return self._get_value_from_conf_file('dns_pid', int)
+
+    def is_dhcrelay_pid(self, pid):
+        pid_path = '/proc/%s/cmdline' % pid
+        if (pid and os.path.isdir('/proc/%s/' % pid) and
+            self.conf.dhcrelay_path in open(pid_path).read()):
+            return True
+        return False
+
+    def is_dhcp_active(self):
+        """Is any dhcprelay still active"""
+        pids = [self.get_dhcp_pid(version=DhcpDnsProxy.DHCPv4)]
+        if self.ipv6_enabled:
+            pids.append(self.get_dhcp_pid(version=DhcpDnsProxy.DHCPv6))
+
+        if not any(pids):
+            return False
+
+        for pid in pids:
+            if self.is_dhcrelay_pid(pid):
+                return True
+        return False
+
+    def is_dns_active(self):
+        pid = self.get_dns_pid()
+        if not pid:
+            return False
+        return os.path.isdir('/proc/%s/' % pid)
+
+    def enable(self):
+        relay_iface_name = self._get_relay_device_name()
+        relay_iface_mac_address = _generate_mac_address()
+        self.device_manager.setup_relay(
+            self.network,
+            relay_iface_name,
+            relay_iface_mac_address,
+            self.conf.dhcp_relay_bridge)
+
+        interface_name = self.device_manager.setup(self.network)
+        if self.is_dhcp_active() or self.is_dns_active():
+            self.restart()
+        elif self._enable_dns_dhcp():
+            self.interface_name = interface_name
+            self.spawn_process()
+
+    def disable(self, retain_port=False):
+        def kill_proc(pid):
+            if not pid:
+                return
+            cmd = ['kill', '-9', pid]
+            utils.execute(cmd, self.root_helper)
+
+        def check_dhcp_pid():
+            if self.ipv6_enabled:
+                return self.get_dhcp_pid(DhcpDnsProxy.DHCPv4) and \
+                    self.get_dhcp_pid(DhcpDnsProxy.DHCPv6)
+            else:
+                return self.get_dhcp_pid(DhcpDnsProxy.DHCPv4)
+
+        def log_dhcp_pid_info():
+            if self.ipv6_enabled:
+                LOG.debug(
+                _('dhcrelay for %(net_id)s, dhcp_pid %(dhcp_pid)d, '
+                  'dhcp6_pid %(dhcp6_pid)d, is stale, ignoring command'),
+                {
+                    'net_id': self.network.id,
+                    'dhcp_pid': self.get_dhcp_pid(DhcpDnsProxy.DHCPv4),
+                    'dhcp6_pid': self.get_dhcp_pid(DhcpDnsProxy.DHCPv6)
+                })
+            else:
+                LOG.debug(
+                _('dhcrelay for %(net_id)s, dhcp_pid %(dhcp_pid)d '
+                  'is stale, ignoring command'),
+                {
+                    'net_id': self.network.id,
+                    'dhcp_pid': self.get_dhcp_pid(DhcpDnsProxy.DHCPv4)
+                })
+
+        if self.is_dhcp_active():
+            kill_proc(self.get_dhcp_pid(DhcpDnsProxy.DHCPv4))
+            if self.ipv6_enabled:
+                kill_proc(self.get_dhcp_pid(DhcpDnsProxy.DHCPv6))
+        elif check_dhcp_pid():
+            log_dhcp_pid_info()
+        else:
+            LOG.debug(_('No dhcrelay started for %s'), self.network.id)
+
+        if self.is_dns_active():
+            kill_proc(self.get_dns_pid())
+        elif self.get_dns_pid():
+            LOG.debug(_('dnsmasq for %(net_id)s, dhcp_pid %(dns_pid)d, is'
+                        ' stale, ignoring command'),
+                      {'net_id': self.network.id,
+                       'dns_pid': self.get_dns_pid()}
+                      )
+        else:
+            LOG.debug(_('No dnsmasq started for %s'), self.network.id)
+
+        if not retain_port:
+            self.device_manager.destroy(self.network, self.interface_name)
+            self.device_manager.destroy_relay(
+                self.network,
+                self._get_relay_device_name(),
+                self.conf.dhcp_relay_bridge)
+
+            if self.conf.dhcp_delete_namespaces and self.network.namespace:
+                ns_ip = ip_lib.IPWrapper(self.root_helper,
+                                         self.network.namespace)
+                try:
+                    ns_ip.netns.delete(self.network.namespace)
+                except RuntimeError:
+                    msg = _('Failed trying to delete namespace: %s')
+                    LOG.exception(msg, self.network.namespace)
+        self._remove_config_files()
+
+    def spawn_process(self):
+        """Spawns a IPAM proxy processes for the network."""
+        self._spawn_dhcp_proxy()
+        self._spawn_dns_proxy()
+
+    def _construct_dhcrelay_commands(self, relay_ips, relay_ipv6s):
+        dhcrelay_v4_command = [
+            self.conf.dhcrelay_path, '-4', '-a',
+            '-pf', self.get_conf_file_name('dhcp4_pid', ensure_conf_dir=True),
+            '-i', self.interface_name]
+
+        ipv6_ok = self.ipv6_enabled
+        if ipv6_ok:
+            dhcrelay_v6_command = [
+                self.conf.dhcrelay_path, '-6', '-I',
+                '-pf', self.get_conf_file_name('dhcp6_pid', ensure_conf_dir=True),
+                '-l', self.interface_name]
+
+        if self.conf.use_link_selection_option:
+            # dhcrelay -4 -a -i iface1 -l iface2 server1 server2
+            dhcrelay_v4_command.append('-o')
+            dhcrelay_v4_command.append(self._get_relay_device_name())
+
+            if ipv6_ok:
+                # dhcrelay -6 -l iface1 -u server1%iface2 -u server2%iface2
+                if relay_ipv6s:
+                    for ipv6_addr in relay_ipv6s:
+                        dhcrelay_v6_command.append('-u')
+
+                        if self.conf.use_ipv6_unicast_requests:
+                            dhcrelay_v6_command.append("%".join((
+                                ipv6_addr, self._get_relay_device_name())))
+                        else:
+                            dhcrelay_v6_command.append(
+                                self._get_relay_device_name())
+
+        dhcrelay_v4_command.append(" ".join(relay_ips))
+
+        if ipv6_ok:
+            return [
+                dhcrelay_v4_command,
+                dhcrelay_v6_command
+            ]
+        else:
+            return [
+                dhcrelay_v4_command
+            ]
+
+    def _spawn_dhcp_proxy(self):
+        """Spawns a dhcrelay process for the network."""
+        relay_ips = self._get_relay_ips('external_dhcp_servers')
+        relay_ipv6s = self._get_relay_ips('external_dhcp_ipv6_servers')
+
+        if not relay_ips:
+            LOG.error(_('DHCP relay server isn\'t defined for network %s'),
+                      self.network.id)
+            return
+
+        commands = self._construct_dhcrelay_commands(relay_ips, relay_ipv6s)
+
+        for cmd in commands:
+            if self.network.namespace:
+                ip_wrapper = ip_lib.IPWrapper(self.root_helper,
+                                              self.network.namespace)
+                try:
+                    ip_wrapper.netns.execute(cmd)
+                except RuntimeError:
+                    LOG.info(_("Can't start dhcrelay for %(command)s"),
+                             {'command': cmd})
+            else:
+                utils.execute(cmd, self.root_helper)
+
+    def _spawn_dns_proxy(self):
+        """Spawns a Dnsmasq process in DNS relay only mode for the network."""
+        relay_ips = self._get_relay_ips('external_dns_servers')
+
+        if not relay_ips:
+            LOG.error(_('DNS relay server isn\'t defined for network %s'),
+                      self.network.id)
+            return
+
+        server_list = []
+        for relay_ip in relay_ips:
+            server_list.append("--server=%s" % relay_ip)
+
+        env = {
+            self.NEUTRON_NETWORK_ID_KEY: self.network.id,
+        }
+
+        cmd = [
+            'dnsmasq',
+            '--no-hosts',
+            '--no-resolv',
+            '--strict-order',
+            '--bind-interfaces',
+            '--interface=%s' % self.interface_name,
+            '--except-interface=lo',
+            '--all-servers']
+        cmd += server_list
+        cmd += ['--pid-file=%s' % self.get_conf_file_name(
+                'dns_pid', ensure_conf_dir=True)]
+
+        if self.network.namespace:
+            ip_wrapper = ip_lib.IPWrapper(self.root_helper,
+                                          self.network.namespace)
+            ip_wrapper.netns.execute(cmd, addl_env=env)
+        else:
+            utils.execute(cmd, self.root_helper, addl_env=env)
+
+    def _get_relay_device_name(self):
+        return (self.RELAY_DEV_NAME_PREFIX +
+                self.network.id)[:self.dev_name_len]
+
+    def _get_relay_ips(self, ip_opt_name):
+        # Try to get relay IP from the config.
+        relay_ips = getattr(self.conf, ip_opt_name, None)
+        # If not specified in config try to get from network object.
+        if not relay_ips:
+            relay_ips = getattr(self.network, ip_opt_name, None)
+
+        if not relay_ips:
+            return None
+
+        try:
+            for relay_ip in relay_ips:
+                netaddr.IPAddress(relay_ip)
+        except netaddr.core.AddrFormatError:
+            LOG.error(_('An invalid option value has been provided:'
+                        ' %(opt_name)s=%(opt_value)s') %
+                      dict(opt_name=ip_opt_name, opt_value=relay_ip))
+            return None
+
+        return list(set(relay_ips))
+
+
+class DnsDhcpProxyDeviceManager(dhcp.DeviceManager):
+    def setup_relay(self, network, iface_name, mac_address, relay_bridge):
+        if ip_lib.device_exists(iface_name,
+                                self.root_helper,
+                                network.namespace):
+            LOG.debug(_('Reusing existing device: %s.'), iface_name)
+        else:
+            self.driver.plug(network.id,
+                             network.id,
+                             iface_name,
+                             mac_address,
+                             namespace=network.namespace,
+                             bridge=relay_bridge)
+
+            use_static_ip_allocation = (
+                self.conf.dhcp_relay_management_network
+                and hasattr(network, MGMT_INTERFACE_IP_ATTR))
+
+            if use_static_ip_allocation:
+                self._allocate_static_ip(network, iface_name)
+            else:
+                self._allocate_ip_via_dhcp(network, iface_name)
+
+    def destroy_relay(self, network, device_name, relay_bridge):
+        self.driver.unplug(device_name, namespace=network.namespace,
+                           bridge=relay_bridge)
+
+    def _allocate_static_ip(self, network, iface_name):
+        mgmt_net = self.conf.dhcp_relay_management_network
+        relay_ip = netaddr.IPAddress(getattr(network, MGMT_INTERFACE_IP_ATTR))
+        relay_net = netaddr.IPNetwork(mgmt_net)
+        relay_ip_cidr = '/'.join([str(relay_ip), str(relay_net.prefixlen)])
+        relay_iface = ip_lib.IPDevice(iface_name, self.root_helper)
+
+        LOG.info(_('Allocating static IP %(relay_ip)s for %(iface_name)s'),
+                 {'relay_ip': relay_ip, 'iface_name': iface_name})
+
+        if network.namespace:
+            relay_iface.namespace = network.namespace
+
+        relay_iface.addr.add(
+            relay_ip.version, relay_ip_cidr, relay_net.broadcast,
+            scope='link')
+
+    def _allocate_ip_via_dhcp(self, network, iface_name):
+        dhcp_client_cmd = [self.conf.dhclient_path, iface_name]
+
+        LOG.info(_('Running DHCP client for %s interface'), iface_name)
+
+        if network.namespace:
+            ip_wrapper = ip_lib.IPWrapper(self.root_helper,
+                                          network.namespace)
+            ip_wrapper.netns.execute(dhcp_client_cmd)
+        else:
+            utils.execute(dhcp_client_cmd)
diff --git a/neutron/agent/linux/interface.py b/neutron/agent/linux/interface.py
index a693cf1..bfb4951 100644
--- a/neutron/agent/linux/interface.py
+++ b/neutron/agent/linux/interface.py
@@ -65,6 +65,9 @@ OPTS = [
                default='publicURL',
                help=_("Network service endpoint type to pull from "
                       "the keystone catalog")),
+    cfg.IntOpt('interface_dev_name_len',
+               default=14,
+               help=_("Maximum interace name length")),
 ]
 
 
@@ -174,7 +177,8 @@ class LinuxInterfaceDriver(object):
             raise exceptions.BridgeDoesNotExist(bridge=bridge)
 
     def get_device_name(self, port):
-        return (self.DEV_NAME_PREFIX + port.id)[:self.DEV_NAME_LEN]
+        return ((self.DEV_NAME_PREFIX + port.id)
+                [:self.conf.interface_dev_name_len])
 
     @abc.abstractmethod
     def plug(self, network_id, port_id, device_name, mac_address,
diff --git a/neutron/common/config.py b/neutron/common/config.py
index cda8d05..9bd5eec 100644
--- a/neutron/common/config.py
+++ b/neutron/common/config.py
@@ -115,6 +115,9 @@ core_opts = [
     cfg.IntOpt('send_events_interval', default=2,
                help=_('Number of seconds between sending events to nova if '
                       'there are any events to send.')),
+    cfg.StrOpt('ipam_driver',
+               default='neutron.ipam.drivers.neutron_ipam.NeutronIPAM',
+               help=_('IPAM driver'))
 ]
 
 core_cli_opts = [
diff --git a/neutron/db/agents_db.py b/neutron/db/agents_db.py
index 0a013d5..aaa3983 100644
--- a/neutron/db/agents_db.py
+++ b/neutron/db/agents_db.py
@@ -115,7 +115,7 @@ class AgentDbMixin(ext_agent.AgentPluginBase):
             conf = {}
         return conf
 
-    def _make_agent_dict(self, agent, fields=None):
+    def _make_agent_dict(self, agent, fields=None, context=None):
         attr = ext_agent.RESOURCE_ATTRIBUTE_MAP.get(
             ext_agent.RESOURCE_NAME + 's')
         res = dict((k, agent[k]) for k in attr
diff --git a/neutron/db/db_base_plugin_v2.py b/neutron/db/db_base_plugin_v2.py
old mode 100644
new mode 100755
index 3df2fe5..f013d40
--- a/neutron/db/db_base_plugin_v2.py
+++ b/neutron/db/db_base_plugin_v2.py
@@ -38,7 +38,6 @@ from neutron.openstack.common import log as logging
 from neutron.openstack.common import uuidutils
 from neutron.plugins.common import constants as service_constants
 
-
 LOG = logging.getLogger(__name__)
 
 # Ports with the following 'device_owner' values will not prevent
@@ -51,8 +50,8 @@ LOG = logging.getLogger(__name__)
 AUTO_DELETE_PORT_OWNERS = [constants.DEVICE_OWNER_DHCP]
 
 
-class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
-                        common_db_mixin.CommonDbMixin):
+class NeutronCorePluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
+                          common_db_mixin.CommonDbMixin):
     """V2 Neutron plugin interface implementation using SQLAlchemy models.
 
     Whenever a non-read call happens the plugin will call an event handler
@@ -136,8 +135,8 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
             if base_mac[3] != '00':
                 mac[3] = int(base_mac[3], 16)
             mac_address = ':'.join(map(lambda x: "%02x" % x, mac))
-            if NeutronDbPluginV2._check_unique_mac(context, network_id,
-                                                   mac_address):
+            if NeutronCorePluginV2._check_unique_mac(context, network_id,
+                                                     mac_address):
                 LOG.debug(_("Generated mac for network %(network_id)s "
                             "is %(mac_address)s"),
                           {'network_id': network_id,
@@ -196,11 +195,11 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
     @staticmethod
     def _generate_ip(context, subnets):
         try:
-            return NeutronDbPluginV2._try_generate_ip(context, subnets)
+            return NeutronCorePluginV2._try_generate_ip(context, subnets)
         except n_exc.IpAddressGenerationFailure:
-            NeutronDbPluginV2._rebuild_availability_ranges(context, subnets)
+            NeutronCorePluginV2._rebuild_availability_ranges(context, subnets)
 
-        return NeutronDbPluginV2._try_generate_ip(context, subnets)
+        return NeutronCorePluginV2._try_generate_ip(context, subnets)
 
     @staticmethod
     def _try_generate_ip(context, subnets):
@@ -431,9 +430,8 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
 
             if 'ip_address' in fixed:
                 # Ensure that the IP's are unique
-                if not NeutronDbPluginV2._check_unique_ip(context, network_id,
-                                                          subnet_id,
-                                                          fixed['ip_address']):
+                if not NeutronCorePluginV2._check_unique_ip(
+                        context, network_id, subnet_id, fixed['ip_address']):
                     raise n_exc.IpAddressInUse(net_id=network_id,
                                                ip_address=fixed['ip_address'])
 
@@ -474,7 +472,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
         for fixed in fixed_ips:
             if 'ip_address' in fixed:
                 # Remove the IP address from the allocation pool
-                NeutronDbPluginV2._allocate_specific_ip(
+                NeutronCorePluginV2._allocate_specific_ip(
                     context, fixed['subnet_id'], fixed['ip_address'])
                 ips.append({'ip_address': fixed['ip_address'],
                             'subnet_id': fixed['subnet_id']})
@@ -523,17 +521,17 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
                                                device_owner)
         for ip in original_ips:
             LOG.debug(_("Port update. Hold %s"), ip)
-            NeutronDbPluginV2._delete_ip_allocation(context,
-                                                    network_id,
-                                                    ip['subnet_id'],
-                                                    ip['ip_address'])
+            NeutronCorePluginV2._delete_ip_allocation(context,
+                                                      network_id,
+                                                      ip['subnet_id'],
+                                                      ip['ip_address'])
 
         if to_add:
             LOG.debug(_("Port update. Adding %s"), to_add)
             ips = self._allocate_fixed_ips(context, to_add, mac_address)
         return ips, prev_ips
 
-    def _allocate_ips_for_port(self, context, port):
+    def _allocate_ips_for_port(self, context, port, port_id):
         """Allocate IP addresses for the port.
 
         If port['fixed_ips'] is set to 'ATTR_NOT_SPECIFIED', allocate IP
@@ -541,6 +539,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
         a subnet_id then allocate an IP address accordingly.
         """
         p = port['port']
+        p['id'] = port_id
         ips = []
 
         fixed_configured = p['fixed_ips'] is not attributes.ATTR_NOT_SPECIFIED
@@ -583,7 +582,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
             version_subnets = [v4, v6_stateful]
             for subnets in version_subnets:
                 if subnets:
-                    result = NeutronDbPluginV2._generate_ip(context, subnets)
+                    result = NeutronCorePluginV2._generate_ip(context, subnets)
                     ips.append({'ip_address': result['ip_address'],
                                 'subnet_id': result['subnet_id']})
         return ips
@@ -830,6 +829,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
                'shared': network['shared'],
                'subnets': [subnet['id']
                            for subnet in network['subnets']]}
+
         # Call auxiliary extend functions, if any
         if process_extensions:
             self._apply_dict_extend_functions(
@@ -861,8 +861,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
         self._apply_dict_extend_functions(attributes.SUBNETS, res, subnet)
         return self._fields(res, fields)
 
-    def _make_port_dict(self, port, fields=None,
-                        process_extensions=True):
+    def _make_port_dict(self, port, fields=None, process_extensions=True):
         res = {"id": port["id"],
                'name': port['name'],
                "network_id": port["network_id"],
@@ -1098,55 +1097,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
 
         self._validate_subnet(context, s)
 
-        tenant_id = self._get_tenant_id_for_create(context, s)
-        with context.session.begin(subtransactions=True):
-            network = self._get_network(context, s["network_id"])
-            self._validate_subnet_cidr(context, network, s['cidr'])
-            # The 'shared' attribute for subnets is for internal plugin
-            # use only. It is not exposed through the API
-            args = {'tenant_id': tenant_id,
-                    'id': s.get('id') or uuidutils.generate_uuid(),
-                    'name': s['name'],
-                    'network_id': s['network_id'],
-                    'ip_version': s['ip_version'],
-                    'cidr': s['cidr'],
-                    'enable_dhcp': s['enable_dhcp'],
-                    'gateway_ip': s['gateway_ip'],
-                    'shared': network.shared}
-            if s['ip_version'] == 6 and s['enable_dhcp']:
-                if attributes.is_attr_set(s['ipv6_ra_mode']):
-                    args['ipv6_ra_mode'] = s['ipv6_ra_mode']
-                if attributes.is_attr_set(s['ipv6_address_mode']):
-                    args['ipv6_address_mode'] = s['ipv6_address_mode']
-            subnet = models_v2.Subnet(**args)
-
-            context.session.add(subnet)
-            if s['dns_nameservers'] is not attributes.ATTR_NOT_SPECIFIED:
-                for addr in s['dns_nameservers']:
-                    ns = models_v2.DNSNameServer(address=addr,
-                                                 subnet_id=subnet.id)
-                    context.session.add(ns)
-
-            if s['host_routes'] is not attributes.ATTR_NOT_SPECIFIED:
-                for rt in s['host_routes']:
-                    route = models_v2.SubnetRoute(
-                        subnet_id=subnet.id,
-                        destination=rt['destination'],
-                        nexthop=rt['nexthop'])
-                    context.session.add(route)
-
-            for pool in s['allocation_pools']:
-                ip_pool = models_v2.IPAllocationPool(subnet=subnet,
-                                                     first_ip=pool['start'],
-                                                     last_ip=pool['end'])
-                context.session.add(ip_pool)
-                ip_range = models_v2.IPAvailabilityRange(
-                    ipallocationpool=ip_pool,
-                    first_ip=pool['start'],
-                    last_ip=pool['end'])
-                context.session.add(ip_range)
-
-        return self._make_subnet_dict(subnet)
+        return s
 
     def _update_subnet_dns_nameservers(self, context, id, s):
         old_dns_list = self._get_dns_by_subnet(context, id)
@@ -1207,7 +1158,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
             first_ip=p['start'], last_ip=p['end'],
             subnet_id=id) for p in s['allocation_pools']]
         context.session.add_all(new_pools)
-        NeutronDbPluginV2._rebuild_availability_ranges(context, [s])
+        NeutronCorePluginV2._rebuild_availability_ranges(context, [s])
         #Gather new pools for result:
         result_pools = [{'start': pool['start'],
                          'end': pool['end']}
@@ -1232,6 +1183,8 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
         s['ip_version'] = db_subnet.ip_version
         s['cidr'] = db_subnet.cidr
         s['id'] = db_subnet.id
+        s['network_id'] = db_subnet.network_id
+        s['tenant_id'] = db_subnet.tenant_id
         self._validate_subnet(context, s, cur_subnet=db_subnet)
 
         if 'gateway_ip' in s and s['gateway_ip'] is not None:
@@ -1283,7 +1236,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
             for a in allocated:
                 if (is_auto_addr_subnet or
                     a.ports.device_owner in AUTO_DELETE_PORT_OWNERS):
-                    NeutronDbPluginV2._delete_ip_allocation(
+                    NeutronCorePluginV2._delete_ip_allocation(
                         context, subnet.network_id, id, a.ip_address)
                 else:
                     raise n_exc.SubnetInUse(subnet_id=id)
@@ -1334,13 +1287,12 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
                 #Note(scollins) Add the generated mac_address to the port,
                 #since _allocate_ips_for_port will need the mac when
                 #calculating an EUI-64 address for a v6 subnet
-                p['mac_address'] = NeutronDbPluginV2._generate_mac(context,
-                                                                   network_id)
+                p['mac_address'] = NeutronCorePluginV2._generate_mac(
+                    context, network_id)
             else:
                 # Ensure that the mac on the network is unique
-                if not NeutronDbPluginV2._check_unique_mac(context,
-                                                           network_id,
-                                                           p['mac_address']):
+                if not NeutronCorePluginV2._check_unique_mac(
+                    context, network_id, p['mac_address']):
                     raise n_exc.MacAddressInUse(net_id=network_id,
                                                 mac=p['mac_address'])
 
@@ -1361,12 +1313,12 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
             context.session.add(db_port)
 
             # Update the IP's for the port
-            ips = self._allocate_ips_for_port(context, port)
+            ips = self._allocate_ips_for_port(context, port, port_id)
             if ips:
                 for ip in ips:
                     ip_address = ip['ip_address']
                     subnet_id = ip['subnet_id']
-                    NeutronDbPluginV2._store_ip_allocation(
+                    NeutronCorePluginV2._store_ip_allocation(
                         context, ip_address, network_id, subnet_id, port_id)
 
         return self._make_port_dict(db_port, process_extensions=False)
@@ -1406,7 +1358,7 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
 
                 # Update ips if necessary
                 for ip in added_ips:
-                    NeutronDbPluginV2._store_ip_allocation(
+                    NeutronCorePluginV2._store_ip_allocation(
                         context, ip['ip_address'], port['network_id'],
                         ip['subnet_id'], port.id)
             # Remove all attributes in p which are not in the port DB model
@@ -1530,3 +1482,210 @@ class NeutronDbPluginV2(neutron_plugin_base_v2.NeutronPluginBaseV2,
                             device_id=device_id)
                 if tenant_id != router['tenant_id']:
                     raise n_exc.DeviceIDNotOwnedByTenant(device_id=device_id)
+
+
+class NeutronIPAMPlugin(NeutronCorePluginV2):
+    @property
+    def ipam(self):
+        return manager.NeutronManager.get_ipam()
+
+    def _update_ips_for_port(self, context, network_id, port_id, original_ips,
+                             new_ips, mac_address, device_owner):
+        """Add or remove IPs from the port."""
+        ips = []
+        # These ips are still on the port and haven't been removed
+        prev_ips = []
+
+        # the new_ips contain all of the fixed_ips that are to be updated
+        if len(new_ips) > cfg.CONF.max_fixed_ips_per_port:
+            msg = _('Exceeded maximim amount of fixed ips per port')
+            raise n_exc.InvalidInput(error_message=msg)
+
+        # Remove all of the intersecting elements
+        for original_ip in original_ips[:]:
+            for new_ip in new_ips[:]:
+                if ('ip_address' in new_ip and
+                    original_ip['ip_address'] == new_ip['ip_address']):
+                    original_ips.remove(original_ip)
+                    new_ips.remove(new_ip)
+                    prev_ips.append(original_ip)
+
+        # Check if the IP's to add are OK
+        to_add = self._test_fixed_ips_for_port(context, network_id,
+                                               new_ips, device_owner)
+
+        for ip in original_ips:
+            LOG.debug(_("Port update. Hold %s"), ip)
+            NeutronIPAMPlugin._delete_ip_allocation(context,
+                                                    network_id,
+                                                    ip['subnet_id'],
+                                                    ip['ip_address'])
+            port = self._get_port(context, port_id)
+            self.ipam.deallocate_ip(context, port, ip)
+
+        if to_add:
+            LOG.debug(_("Port update. Adding %s"), to_add)
+            ips = self._allocate_fixed_ips(context, to_add, mac_address)
+
+        return ips, prev_ips
+
+    def _allocate_ips_for_port(self, context, port, port_id):
+        """Allocate IP addresses for the port.
+
+        If port['fixed_ips'] is set to 'ATTR_NOT_SPECIFIED', allocate IP
+        addresses for the port. If port['fixed_ips'] contains an IP address or
+        a subnet_id then allocate an IP address accordingly.
+        """
+        p = port['port']
+        p['id'] = port_id
+        ips = []
+
+        fixed_configured = p['fixed_ips'] is not attributes.ATTR_NOT_SPECIFIED
+        if fixed_configured:
+            configured_ips = self._test_fixed_ips_for_port(context,
+                                                           p["network_id"],
+                                                           p['fixed_ips'],
+                                                           p['device_owner'])
+
+            for ip in configured_ips:
+                ips.append(self.ipam.allocate_ip(context, p, ip=ip))
+        else:
+            filter = {'network_id': [p['network_id']]}
+            subnets = self.get_subnets(context, filters=filter)
+            # Split into v4 and v6 subnets
+            v4 = []
+            v6_stateful = []
+            v6_stateless = []
+            for subnet in subnets:
+                if subnet['ip_version'] == 4:
+                    v4.append(subnet)
+                else:
+                    if ipv6_utils.is_auto_address_subnet(subnet):
+                        v6_stateless.append(subnet)
+                    else:
+                        v6_stateful.append(subnet)
+
+            for subnet in v6_stateless:
+                prefix = subnet['cidr']
+                ip_address = ipv6_utils.get_ipv6_addr_by_EUI64(
+                    prefix, p['mac_address'])
+                if not self._check_unique_ip(
+                    context, p['network_id'],
+                    subnet['id'], ip_address.format()):
+                    raise n_exc.IpAddressInUse(
+                        net_id=p['network_id'],
+                        ip_address=ip_address.format())
+                ips.append({'ip_address': ip_address.format(),
+                            'subnet_id': subnet['id']})
+
+            version_subnets = [v4, v6_stateful]
+            for subnets in version_subnets:
+                if subnets:
+                    ip = None
+                    for subnet in subnets:
+                        ip = self.ipam.allocate_ip(
+                            context, p, ip={'subnet_id': subnet['id']})
+                        if ip:
+                            ips.append(ip)
+                            break
+                    if not ip:
+                        raise n_exc.IpAddressGenerationFailure(
+                                    net_id=subnet['network_id'])
+
+        return ips
+
+    def _update_subnet_dns_nameservers(self, context, id, s):
+        subnet, dhcp_changes = self.ipam.update_subnet(context, id, s)
+
+        result = self._make_subnet_dict(subnet)
+        # Keep up with fields that changed
+        if 'new_dns' in dhcp_changes:
+            result['dns_nameservers'] = dhcp_changes['new_dns']
+        if 'new_routes' in dhcp_changes:
+            result['host_routes'] = dhcp_changes['new_routes']
+        if "dns_nameservers" in s:
+            del s["dns_nameservers"]
+        return dhcp_changes['new_dns']
+
+    def create_subnet(self, context, subnet):
+        s = super(NeutronIPAMPlugin, self).create_subnet(context, subnet)
+        with context.session.begin(subtransactions=True):
+            network = self._get_network(context, s["network_id"])
+            self._validate_subnet_cidr(context, network, s['cidr'])
+            subnet = self.ipam.create_subnet(context, s)
+        return subnet
+
+    def delete_subnet(self, context, id):
+        with context.session.begin(subtransactions=True):
+            subnet = self._get_subnet(context, id)
+            self.ipam.delete_subnet(context, subnet)
+            super(NeutronIPAMPlugin, self).delete_subnet(context, id)
+
+    def create_network(self, context, network):
+        net = super(NeutronIPAMPlugin, self).create_network(context,
+                                                            network)
+        n = network['network']
+        n['id'] = net['id']
+        self.ipam.create_network(context, n)
+
+        return net
+
+    def get_networks(self, context, filters=None, fields=None,
+                     sorts=None, limit=None, marker=None,
+                     page_reverse=False):
+        nets = super(NeutronIPAMPlugin, self).get_networks(
+            context, filters, fields, sorts, limit, marker, page_reverse)
+
+        for net in nets:
+            if 'id' in net:
+                net.update(self.ipam.get_additional_network_dict_params(
+                    context, net['id']))
+
+        return nets
+
+    def delete_network(self, context, id):
+        with context.session.begin(subtransactions=True):
+            network = self._get_network(context, id)
+            self.ipam.delete_network(context, network)
+            super(NeutronIPAMPlugin, self).delete_network(context, id)
+
+    def update_network(self, context, id, network):
+        n = super(NeutronIPAMPlugin, self).update_network(context,
+                                                          id, network)
+
+        subnets = self._get_subnets_by_network(context, id)
+        for subnet in subnets:
+            self.ipam.update_subnet(context, subnet['id'], subnet)
+
+        return n
+
+    def create_port(self, context, port):
+        port_dict = super(NeutronIPAMPlugin, self).create_port(context,
+                                                               port)
+        self.ipam.create_port(context, port_dict)
+        return port_dict
+
+    def _delete_port(self, context, id):
+        query = (context.session.query(models_v2.Port).
+                 enable_eagerloads(False).filter_by(id=id))
+        if not context.is_admin:
+            query = query.filter_by(tenant_id=context.tenant_id)
+
+        port = query.with_lockmode('update').one()
+        self.ipam.delete_port(context, port)
+
+        allocated_qry = context.session.query(
+            models_v2.IPAllocation).with_lockmode('update')
+        # recycle all of the IP's
+        allocated = allocated_qry.filter_by(port_id=id)
+        host = dict(name=(port.get('id') or uuidutils.generate_uuid()),
+                    mac_address=port['mac_address'])
+        for a in allocated:
+            ip = dict(subnet_id=a['subnet_id'],
+                      ip_address=a['ip_address'])
+            self.ipam.deallocate_ip(context, host, ip)
+
+        query.delete()
+
+
+NeutronDbPluginV2 = NeutronIPAMPlugin
diff --git a/neutron/db/infoblox/__init__.py b/neutron/db/infoblox/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/db/infoblox/infoblox_db.py b/neutron/db/infoblox/infoblox_db.py
new file mode 100755
index 0000000..b3b4d81
--- /dev/null
+++ b/neutron/db/infoblox/infoblox_db.py
@@ -0,0 +1,294 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from oslo.config import cfg
+from sqlalchemy.orm import exc
+
+import functools
+import time
+
+from oslo.config import cfg
+from neutron.db import external_net_db
+from neutron.db.infoblox import models
+from neutron.db import l3_db
+from neutron.db import models_v2
+from neutron.openstack.common import log as logging
+#from neutron.openstack.common.db import exception as db_exc
+from oslo.db import exception as db_exc
+
+
+OPTS = [
+    cfg.IntOpt('infoblox_db_retry_interval',
+               default=5,
+               help=_('Seconds between db connection retries')),
+    cfg.IntOpt('infoblox_db_max_try',
+               default=20,
+               help=_('Maximum retries before error is raised. '
+                      '(setting -1 implies an infinite retry count)')),
+    cfg.BoolOpt('infoblox_db_inc_retry_interval',
+                default=True,
+                help=_('Whether to increase interval between retries, '
+                       'up to infoblox_db_max_retry_interval')),
+    cfg.IntOpt('infoblox_db_max_retry_interval',
+               default=600,
+               help='Max seconds for total retries, if '
+                    'infoblox_db_inc_retry_interval is enabled')
+]
+
+cfg.CONF.register_opts(OPTS)
+
+LOG = logging.getLogger(__name__)
+
+
+def _retry_db_error(func):
+    @functools.wraps(func)
+    def callee(*args, **kwargs):
+        next_interval = cfg.CONF.infoblox_db_retry_interval
+        remaining = cfg.CONF.infoblox_db_max_try
+        while True:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                LOG.warn(_("DB error on %s: %s"
+                           % (func, str(e))))
+                if remaining == 0:
+                    LOG.exception(_('DB exceeded retry limit.'))
+                    raise db_exc.DBError(e)
+                if remaining != -1:
+                    remaining -= 1
+                time.sleep(next_interval)
+                if cfg.CONF.infoblox_db_inc_retry_interval:
+                    next_interval = min(
+                        next_interval * 2,
+                        cfg.CONF.infoblox_db_max_retry_interval
+                    )
+    return callee
+
+
+def get_used_members(context, member_type):
+    """Returns used members where map_id is not null."""
+    q = context.session.query(models.InfobloxMemberMap)
+    members = q.filter(models.InfobloxMemberMap.member_type ==
+                       member_type).\
+        filter(models.InfobloxMemberMap.map_id.isnot(None)).\
+        distinct()
+    return members
+
+
+def get_registered_members(context, member_type):
+    """Returns registered members."""
+    q = context.session.query(models.InfobloxMemberMap)
+    members = q.filter_by(member_type=member_type).distinct()
+    return members
+
+
+@_retry_db_error
+def get_available_member(context, member_type):
+    """Returns available members."""
+    q = context.session.query(models.InfobloxMemberMap)
+    q = q.filter(models.InfobloxMemberMap.member_type == member_type)
+    member = q.filter(models.InfobloxMemberMap.map_id.is_(None)).\
+        with_lockmode("update").\
+        first()
+    return member
+
+
+def get_members(context, map_id, member_type):
+    """Returns members used by currently used mapping (tenant id,
+    network id or Infoblox netview name).
+    """
+    q = context.session.query(models.InfobloxMemberMap)
+    members = q.filter_by(map_id=map_id, member_type=member_type).all()
+    return members
+
+
+def register_member(context, map_id, member_name, member_type):
+    if map_id:
+        context.session.add(
+            models.InfobloxMemberMap(map_id=map_id,
+                                     member_name=member_name,
+                                     member_type=member_type))
+    else:
+        context.session.add(
+            models.InfobloxMemberMap(member_name=member_name,
+                                     member_type=member_type))
+
+
+def attach_member(context, map_id, member_name, member_type):
+    context.session.query(models.InfobloxMemberMap.member_name).\
+        filter_by(member_name=member_name, member_type=member_type).\
+        update({'map_id': map_id})
+
+
+def delete_members(context, map_id):
+    with context.session.begin(subtransactions=True):
+        context.session.query(
+            models.InfobloxMemberMap).filter_by(map_id=map_id).delete()
+
+
+@_retry_db_error
+def release_member(context, map_id):
+    context.session.query(models.InfobloxMemberMap.member_name).\
+        filter_by(map_id=map_id).update({'map_id': None})
+
+
+def is_last_subnet(context, subnet_id):
+    q = context.session.query(models_v2.Subnet)
+    return q.filter(models_v2.Subnet.id != subnet_id).count() == 0
+
+
+def is_last_subnet_in_network(context, subnet_id, network_id):
+    q = context.session.query(models_v2.Subnet)
+    return q.filter(models_v2.Subnet.id != subnet_id,
+                    models_v2.Subnet.network_id == network_id).count() == 0
+
+
+def is_last_subnet_in_tenant(context, subnet_id, tenant_id):
+    q = context.session.query(models_v2.Subnet)
+    return q.filter(models_v2.Subnet.id != subnet_id,
+                    models_v2.Subnet.tenant_id == tenant_id).count() == 0
+
+
+def is_last_subnet_in_private_networks(context, subnet_id):
+    sub_qry = context.session.query(
+        external_net_db.ExternalNetwork.network_id)
+    q = context.session.query(models_v2.Subnet.id)
+    q = q.filter(models_v2.Subnet.id != subnet_id)
+    q = q.filter(~models_v2.Subnet.network_id.in_(sub_qry))
+    return q.count() == 0
+
+
+def is_network_external(context, network_id):
+    q = context.session.query(external_net_db.ExternalNetwork)
+    return q.filter_by(network_id=network_id).count() > 0
+
+
+def delete_ip_allocation(context, network_id, subnet, ip_address):
+    # Delete the IP address from the IPAllocate table
+    subnet_id = subnet['id']
+    LOG.debug(_("Delete allocated IP %(ip_address)s "
+                "(%(network_id)s/%(subnet_id)s)"), locals())
+    alloc_qry = context.session.query(
+        models_v2.IPAllocation).with_lockmode('update')
+    alloc_qry.filter_by(network_id=network_id,
+                        ip_address=ip_address,
+                        subnet_id=subnet_id).delete()
+
+
+def get_subnets_by_network(context, network_id):
+    subnet_qry = context.session.query(models_v2.Subnet)
+    return subnet_qry.filter_by(network_id=network_id).all()
+
+
+def get_subnets_by_port(context, port_id):
+    allocs = (context.session.query(models_v2.IPAllocation).
+              join(models_v2.Port).
+              filter_by(id=port_id)
+              .all())
+    subnets = []
+    subnet_qry = context.session.query(models_v2.Subnet)
+    for allocation in allocs:
+        subnets.append(subnet_qry.
+                       filter_by(id=allocation.subnet_id).
+                       first())
+    return subnets
+
+
+def get_port_by_id(context, port_id):
+    query = context.session.query(models_v2.Port)
+    return query.filter_by(id=port_id).one()
+
+
+def get_network_name(context, subnet):
+    q = context.session.query(models_v2.Network)
+    net_name = q.join(models_v2.Subnet).filter(
+        models_v2.Subnet.id == subnet['id']).first()
+    if net_name:
+        return net_name.name
+    return None
+
+
+def get_instance_id_by_floating_ip(context, floating_ip_id):
+    query = context.session.query(l3_db.FloatingIP, models_v2.Port)
+    query = query.filter(l3_db.FloatingIP.id == floating_ip_id)
+    query = query.filter(models_v2.Port.id == l3_db.FloatingIP.fixed_port_id)
+    result = query.first()
+    if result:
+        return result.Port.device_id
+    return None
+
+
+def get_subnet_dhcp_port_address(context, subnet_id):
+    dhcp_port = (context.session.query(models_v2.IPAllocation).
+                 filter_by(subnet_id=subnet_id).
+                 join(models_v2.Port).
+                 filter_by(device_owner='network:dhcp')
+                 .first())
+    if dhcp_port:
+        return dhcp_port.ip_address
+    return None
+
+
+def get_network_view(context, network_id):
+    query = context.session.query(models.InfobloxNetViews)
+    net_view = query.filter_by(network_id=network_id).first()
+    if net_view:
+        return net_view.network_view
+    return None
+
+
+def set_network_view(context, network_view, network_id):
+    ib_net_view = models.InfobloxNetViews(network_id=network_id,
+                                          network_view=network_view)
+
+    # there should be only one NIOS network view per Openstack network
+    query = context.session.query(models.InfobloxNetViews)
+    obj = query.filter_by(network_id=network_id).first()
+    if not obj:
+        context.session.add(ib_net_view)
+
+
+def add_management_ip(context, network_id, fixed_address):
+    context.session.add(models.InfobloxManagementNetIps(
+        network_id=network_id,
+        ip_address=fixed_address.ip,
+        fixed_address_ref=fixed_address.ref))
+
+
+def delete_management_ip(context, network_id):
+    query = context.session.query(models.InfobloxManagementNetIps)
+    query.filter_by(network_id=network_id).delete()
+
+
+def get_management_ip_ref(context, network_id):
+    query = context.session.query(models.InfobloxManagementNetIps)
+    mgmt_ip = query.filter_by(network_id=network_id).first()
+    return mgmt_ip.fixed_address_ref if mgmt_ip else None
+
+
+def get_management_net_ip(context, network_id):
+    query = context.session.query(models.InfobloxManagementNetIps)
+    mgmt_ip = query.filter_by(network_id=network_id).first()
+    return mgmt_ip.ip_address if mgmt_ip else None
+
+
+def get_network(context, network_id):
+    network_qry = context.session.query(models_v2.Network)
+    return network_qry.filter_by(id=network_id).one()
+
+
+def get_subnet(context, subnet_id):
+    subnet_qry = context.session.query(models_v2.Subnet)
+    return subnet_qry.filter_by(id=subnet_id).one()
diff --git a/neutron/db/infoblox/models.py b/neutron/db/infoblox/models.py
new file mode 100755
index 0000000..2f2bd5e
--- /dev/null
+++ b/neutron/db/infoblox/models.py
@@ -0,0 +1,82 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2012 OpenStack Foundation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import sqlalchemy as sa
+
+from neutron.db import model_base
+from neutron.db import models_v2
+
+
+DHCP_MEMBER_TYPE = 'dhcp'
+DNS_MEMBER_TYPE = 'dns'
+
+
+class InfobloxDNSMember(model_base.BASEV2, models_v2.HasId):
+    __tablename__ = 'infoblox_dns_members'
+
+    network_id = sa.Column(sa.String(36), sa.ForeignKey('networks.id',
+                                                        ondelete="CASCADE"))
+    server_ip = sa.Column(sa.String(40))
+    server_ipv6 = sa.Column(sa.String(40))
+
+
+class InfobloxDHCPMember(model_base.BASEV2, models_v2.HasId):
+    __tablename__ = 'infoblox_dhcp_members'
+
+    network_id = sa.Column(sa.String(36), sa.ForeignKey('networks.id',
+                                                        ondelete="CASCADE"))
+    server_ip = sa.Column(sa.String(40))
+    server_ipv6 = sa.Column(sa.String(40))
+
+
+class InfobloxMemberMap(model_base.BASEV2):
+    """Maps Neutron object to Infoblox member.
+
+    map_id may point to Network ID, Tenant ID or Infoblox network view name
+    depending on configuration. Infoblox member names are unique.
+    """
+    __tablename__ = 'infoblox_member_maps'
+
+    member_name = sa.Column(sa.String(255), nullable=False, primary_key=True)
+    map_id = sa.Column(sa.String(255), nullable=True)
+    member_type = sa.Column(sa.String(10))
+
+
+class InfobloxNetViews(model_base.BASEV2):
+    """Connects Infoblox network views with Openstack networks.
+    This is needed to properly delete network views in NIOS on network
+    delete
+    """
+
+    __tablename__ = 'infoblox_net_views'
+
+    network_id = sa.Column(sa.String(36), sa.ForeignKey("networks.id",
+                                                        ondelete="CASCADE"),
+                           nullable=False, primary_key=True)
+    network_view = sa.Column(sa.String(56))
+
+
+class InfobloxManagementNetIps(model_base.BASEV2):
+    """Holds IP addresses allocated on management network for DHCP relay
+    interface
+    """
+
+    __tablename__ = 'infoblox_mgmt_net_ips'
+
+    network_id = sa.Column(sa.String(length=255), primary_key=True)
+    ip_address = sa.Column(sa.String(length=64), nullable=False)
+    fixed_address_ref = sa.Column(sa.String(length=255), nullable=False)
diff --git a/neutron/db/l3_db.py b/neutron/db/l3_db.py
index 2c915cd..2e037af 100644
--- a/neutron/db/l3_db.py
+++ b/neutron/db/l3_db.py
@@ -458,6 +458,8 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase):
                                               subnet['id'],
                                               subnet['cidr'])
             port.update({'device_id': router.id, 'device_owner': owner})
+            ipam = manager.NeutronManager.get_ipam()
+            ipam.update_port(context, port)
             return port
 
     def _add_interface_by_subnet(self, context, router, subnet_id, owner):
@@ -810,9 +812,12 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase):
             fip['tenant_id'] = floatingip_db['tenant_id']
             fip['id'] = id
             fip_port_id = floatingip_db['floating_port_id']
-            self._update_fip_assoc(context, fip, floatingip_db,
-                                   self._core_plugin.get_port(
-                                       context.elevated(), fip_port_id))
+            port = self._core_plugin.get_port(context.elevated(),
+                                              fip_port_id)
+            self._update_fip_assoc(context, fip, floatingip_db, port)
+            ipam = manager.NeutronManager.get_ipam()
+            ipam.associate_floatingip(context, floatingip, port)
+
         return old_floatingip, self._make_floatingip_dict(floatingip_db)
 
     def _floatingips_to_router_ids(self, floatingips):
@@ -920,6 +925,10 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase):
             floating_ips = fip_qry.filter_by(fixed_port_id=port_id)
             for floating_ip in floating_ips:
                 router_ids.add(floating_ip['router_id'])
+
+                ipam = manager.NeutronManager.get_ipam()
+                ipam.disassociate_floatingip(context, floating_ip, port_id)
+
                 floating_ip.update({'fixed_port_id': None,
                                     'fixed_ip_address': None,
                                     'router_id': None})
diff --git a/neutron/db/migration/alembic_migrations/versions/172ace2194db_infoblox_net_view_to_network_id.py b/neutron/db/migration/alembic_migrations/versions/172ace2194db_infoblox_net_view_to_network_id.py
new file mode 100644
index 0000000..76c37c1
--- /dev/null
+++ b/neutron/db/migration/alembic_migrations/versions/172ace2194db_infoblox_net_view_to_network_id.py
@@ -0,0 +1,48 @@
+# Copyright 2014 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+"""Infoblox net view to network ID
+
+Revision ID: 172ace2194db
+Revises: d9841b33bd
+Create Date: 2014-09-09 11:03:23.737412
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '172ace2194db'
+down_revision = 'd9841b33bd'
+
+# Change to ['*'] if this migration applies to all plugins
+
+migration_for_plugins = ['*']
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade(active_plugins=None, options=None):
+    op.create_table('infoblox_net_views',
+                    sa.Column('network_id',
+                              sa.String(36),
+                              sa.ForeignKey("networks.id",
+                                            ondelete="CASCADE"),
+                              nullable=False,
+                              primary_key=True),
+                    sa.Column('network_view', sa.String(56)))
+
+
+def downgrade(active_plugins=None, options=None):
+    op.drop_table('infoblox_net_views')
diff --git a/neutron/db/migration/alembic_migrations/versions/256b90dd9824_multiple_dhcp_members.py b/neutron/db/migration/alembic_migrations/versions/256b90dd9824_multiple_dhcp_members.py
new file mode 100644
index 0000000..3445cc8
--- /dev/null
+++ b/neutron/db/migration/alembic_migrations/versions/256b90dd9824_multiple_dhcp_members.py
@@ -0,0 +1,62 @@
+# Copyright 2014 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+"""Multiple DHCP members
+
+Revision ID: 256b90dd9824
+Revises: 172ace2194db
+Create Date: 2014-09-15 05:54:38.612277
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '256b90dd9824'
+down_revision = '172ace2194db'
+
+# Change to ['*'] if this migration applies to all plugins
+
+migration_for_plugins = [
+    '*'
+]
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade(active_plugins=None, options=None):
+    op.create_table(
+        'infoblox_dhcp_members',
+        sa.Column('id', sa.String(length=36), nullable=False),
+        sa.Column('network_id', sa.String(length=36), nullable=False),
+        sa.Column('server_ip', sa.String(length=40), nullable=False),
+        sa.Column('server_ipv6', sa.String(length=40), nullable=True),
+        sa.ForeignKeyConstraint(['network_id'], ['networks.id'],
+                                ondelete='CASCADE'),
+        sa.PrimaryKeyConstraint('id'))
+
+    op.create_table(
+        'infoblox_dns_members',
+        sa.Column('id', sa.String(length=36), nullable=False),
+        sa.Column('network_id', sa.String(length=36), nullable=False),
+        sa.Column('server_ip', sa.String(length=40), nullable=False),
+        sa.Column('server_ipv6', sa.String(length=40), nullable=True),
+        sa.ForeignKeyConstraint(['network_id'], ['networks.id'],
+                                ondelete='CASCADE'),
+        sa.PrimaryKeyConstraint('id'))
+
+
+def downgrade(active_plugins=None, options=None):
+    op.drop_table('infoblox_dhcp_members')
+    op.drop_table('infoblox_dns_members')
diff --git a/neutron/db/migration/alembic_migrations/versions/33150f5993b6_infoblox_management_net_handling.py b/neutron/db/migration/alembic_migrations/versions/33150f5993b6_infoblox_management_net_handling.py
new file mode 100644
index 0000000..e3ef4ae
--- /dev/null
+++ b/neutron/db/migration/alembic_migrations/versions/33150f5993b6_infoblox_management_net_handling.py
@@ -0,0 +1,58 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+"""Infoblox management net handling
+
+Currently DHCP relay is using dynamic DHCP to get the management IP address.
+This is not desirable from customer point of view as they do want a static IP
+assignment for such cases which will reduce any potential issue.
+
+Revision ID: 33150f5993b6
+Revises: 256b90dd9824
+Create Date: 2014-08-28 14:40:20.585390
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '33150f5993b6'
+down_revision = '256b90dd9824'
+
+# Change to ['*'] if this migration applies to all plugins
+
+migration_for_plugins = [
+    '*'
+]
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade(active_plugins=None, options=None):
+    op.create_table('infoblox_mgmt_net_ips',
+                    sa.Column('network_id',
+                              sa.String(length=255),
+                              primary_key=True),
+                    sa.Column('ip_address',
+                              sa.String(length=64),
+                              nullable=False),
+                    sa.Column('fixed_address_ref',
+                              sa.String(length=255),
+                              nullable=False))
+
+
+def downgrade(active_plugins=None, options=None):
+    op.drop_table('infoblox_mgmt_net_ips')
diff --git a/neutron/db/migration/alembic_migrations/versions/78d27e9172_infoblox_db_v2.py b/neutron/db/migration/alembic_migrations/versions/78d27e9172_infoblox_db_v2.py
new file mode 100755
index 0000000..4fcf87b
--- /dev/null
+++ b/neutron/db/migration/alembic_migrations/versions/78d27e9172_infoblox_db_v2.py
@@ -0,0 +1,46 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+"""Infoblox DB v2
+
+Revision ID: 78d27e9172
+Revises: 45284803ad19
+Create Date: 2014-05-28 11:11:34.815843
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '78d27e9172'
+down_revision = 'juno'
+
+# Change to ['*'] if this migration applies to all plugins
+
+migration_for_plugins = ['*']
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade(active_plugins=None, options=None):
+    op.create_table(
+        'infoblox_member_maps',
+        sa.Column('member_name', sa.String(255), nullable=False),
+        sa.Column('map_id', sa.String(255), nullable=True))
+
+
+def downgrade(active_plugins=None, options=None):
+    op.drop_table('infoblox_member_maps')
diff --git a/neutron/db/migration/alembic_migrations/versions/HEAD b/neutron/db/migration/alembic_migrations/versions/HEAD
index 7a30775..a27236f 100644
--- a/neutron/db/migration/alembic_migrations/versions/HEAD
+++ b/neutron/db/migration/alembic_migrations/versions/HEAD
@@ -1 +1 @@
-juno
+172ace2194db
diff --git a/neutron/db/migration/alembic_migrations/versions/d9841b33bd_add_infoblox_member_type.py b/neutron/db/migration/alembic_migrations/versions/d9841b33bd_add_infoblox_member_type.py
new file mode 100644
index 0000000..de2b39b
--- /dev/null
+++ b/neutron/db/migration/alembic_migrations/versions/d9841b33bd_add_infoblox_member_type.py
@@ -0,0 +1,45 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+
+"""Add Infoblox member type
+
+Revision ID: d9841b33bd
+Revises: 78d27e9172
+Create Date: 2014-06-23 18:25:15.557835
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = 'd9841b33bd'
+down_revision = '78d27e9172'
+
+# Change to ['*'] if this migration applies to all plugins
+
+migration_for_plugins = ['*']
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade(active_plugins=None, options=None):
+    op.add_column('infoblox_member_maps',
+                  sa.Column('member_type', sa.String(10)))
+    op.execute("UPDATE infoblox_member_maps SET member_type='dhcp'")
+
+
+def downgrade(active_plugins=None, options=None):
+    op.drop_column('infoblox_member_maps', 'member_type')
diff --git a/neutron/ipam/__init__.py b/neutron/ipam/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/ipam/base.py b/neutron/ipam/base.py
new file mode 100644
index 0000000..2109c46
--- /dev/null
+++ b/neutron/ipam/base.py
@@ -0,0 +1,357 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import abc
+
+import six
+
+from neutron.ipam.drivers import neutron_db
+from neutron.openstack.common import log as logging
+
+# Ports with the following 'device_owner' values will not prevent
+# network deletion.  If delete_network() finds that all ports on a
+# network have these owners, it will explicitly delete each port
+# and allow network deletion to continue.  Similarly, if delete_subnet()
+# finds out that all existing IP Allocations are associated with ports
+# with these owners, it will allow subnet deletion to proceed with the
+# IP allocations being cleaned up by cascade.
+AUTO_DELETE_PORT_OWNERS = ['network:dhcp']
+
+LOG = logging.getLogger(__name__)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class DHCPController(neutron_db.NeutronPluginController):
+    """Base class for IPAM DHCP controller. Incapsulates logic for handling
+    DHCP service related actions.
+    """
+
+    @abc.abstractmethod
+    def configure_dhcp(self, context, backend_subnet, dhcp_params):
+        """Implement this if you need extra actions to be taken on DHCP server
+        during subnet creation.
+        :param backend_subnet: models_v2.Subnet object, represents a subnet
+         being created
+        :param dhcp_params: dict with DHCP arguments, such as dns_nameservers,
+         and host_routes
+         """
+        pass
+
+    @abc.abstractmethod
+    def reconfigure_dhcp(self, context, backend_subnet, dhcp_params):
+        """This is called on subnet update. Implement if DHCP needs to be
+        reconfigured on subnet change
+        :param backend_subnet: models_v2.Subnet object being updated
+        :param dhcp_params: dict with DHCP parameters, such as DNS nameservers,
+         and host routes
+         """
+        pass
+
+    @abc.abstractmethod
+    def disable_dhcp(self, context, backend_subnet):
+        """This is called on subnet delete. Implement if DHCP service needs to
+        be disabled for a given subnet.
+        :param backend_subnet: models_v2.Subnet object being deleted
+        """
+        pass
+
+    @abc.abstractmethod
+    def dhcp_is_enabled(self, context, backend_subnet):
+        """Returns True if DHDC service is enabled for a subnet, False
+        otherwise
+        :param backend_subnet: models_v2.Subnet object
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_dhcp_ranges(self, context, backend_subnet):
+        """Returns DHCP range for a subnet
+        :param backend_subnet: models_v2.Subnet object
+        """
+        pass
+
+    @abc.abstractmethod
+    def bind_mac(self, context, backend_subnet, ip_address, mac_address):
+        """Binds IP address with MAC.
+        :param backend_subnet: models_v2.Subnet object
+        :param ip_address: IP address to be bound
+        :param mac_address: MAC address to be bound
+        """
+        pass
+
+    @abc.abstractmethod
+    def unbind_mac(self, context, backend_subnet, ip_address):
+        """Inverse action for bind_mac.
+        :param backend_subnet: models_v2.Subnet object;
+        :param ip_address: IP address to be unbound
+        """
+        pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class DNSController(neutron_db.NeutronPluginController):
+    """Incapsulates DNS related logic"""
+
+    @abc.abstractmethod
+    def bind_names(self, context, backend_port):
+        """Associate domain name with IP address for a given port
+        :param backend_port: models_v2.Port object
+        """
+        pass
+
+    @abc.abstractmethod
+    def unbind_names(self, context, backend_port):
+        """Disassociate domain name from a given port
+        :param backend_port: models_v2.Port object
+        """
+        pass
+
+    @abc.abstractmethod
+    def create_dns_zones(self, context, backend_subnet):
+        """Creates domain name space for a given subnet. This is called on
+        subnet creation.
+        :param backend_subnet: models_v2.Subnet object
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_dns_zones(self, context, backend_subnet):
+        """Deletes domain name space associated with a subnet. Called on
+        delete subnet.
+        :param backend_subnet: models_v2.Subnet object
+        """
+        pass
+
+    @abc.abstractmethod
+    def disassociate_floatingip(self, context, floatingip, port_id):
+        """Called when floating IP gets disassociated from port
+        :param floatingip: l3_db.FloatingIP object to be disassociated
+        :param port_id: UUID of a port being disassociated
+        """
+        pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class IPAMController(neutron_db.NeutronPluginController):
+    """IP address management controller. Operates with higher-level entities
+    like networks, subnets and ports
+    """
+
+    @abc.abstractmethod
+    def create_subnet(self, context, subnet):
+        """Creates allocation pools and IP ranges for a subnet.
+
+        :param subnet: user-supplied subnet
+        :return models_v2.Subnet object.
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_subnet(self, context, subnet_id, subnet):
+        """Called on subnet update.
+        :param subnet_id: ID of a subnet being updated
+        :param subnet: user-supplied subnet object (dict)
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_subnet(self, context, subnet):
+        """Called on subnet delete. Remove all the higher-level objects
+        associated with a subnet
+        :param subnet: user-supplied subnet object (dict)
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_subnets(self, context, filters=None, fields=None,
+                    sorts=None, limit=None, marker=None,
+                    page_reverse=False):
+        pass
+
+    @abc.abstractmethod
+    def force_off_ports(self, context, ports):
+        """Disable ports on subnet delete event
+        :param ports: list of models_v2.Port objects to be disabled
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_subnet_by_id(self, context, subnet_id):
+        """Returns subnet by UUID
+        :param subnet_id: UUID of a subnet
+        """
+        pass
+
+    @abc.abstractmethod
+    def allocate_ip(self, context, backend_subnet, host, ip=None):
+        """Allocates IP address based either on a subnet's IP range or an IP
+        address provided as an argument
+        :param backend_subnet: models_v2.Subnet object
+        :param host: port which needs IP generated
+        :param ip: IP address to be allocated for a port/host. If not set, IP
+        address will be generated from subnet range
+        :returns: IP address allocated
+        """
+        pass
+
+    @abc.abstractmethod
+    def deallocate_ip(self, context, backend_subnet, host, ip):
+        """Frees IP allocation for a given address
+        :param backend_subnet: models_v2.Subnet object
+        :param host: host/port which has IP allocated
+        :param ip: IP address to be revoked
+        """
+        pass
+
+    @abc.abstractmethod
+    def create_network(self, context, network):
+        """Creates network in the database
+        :param network: user-supplied network object (dict)
+        :returns: models_v2.Network object
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_network(self, context, network_id):
+        """Deletes network from the database
+        :param network_id: UUID of a network to be deleted
+        """
+        pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class IPAMManager(object):
+    """IPAM subsystem manager class which controls IPAM by calling DCHP, DNS
+    and IPAM controller methods
+    """
+
+    @abc.abstractmethod
+    def create_subnet(self, context, subnet):
+        """Called on subnet create event
+        :param subnet: user-supplied subnet object (dict)
+        :returns: models_v2.Subnet object being created
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_subnet(self, context, id, subnet):
+        """Called on subnet update event
+        :param id: UUID of a subnet being updated
+        :param subnet: user-supplied subnet object (dict)
+        :returns: updated subnet
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_subnet(self, context, subnet_id):
+        """Called on delete subnet event
+        :param subnet_id: UUID of a subnet to be deleted
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_subnets_by_network(self, context, network_id):
+        pass
+
+    @abc.abstractmethod
+    def get_subnet_by_id(self, context, subnet_id):
+        pass
+
+    @abc.abstractmethod
+    def allocate_ip(self, context, host, ip):
+        """Called on port create event. Incapsulates logic associated with IP
+        allocation process.
+        :param host: host/port which needs IP to be allocated
+        :param ip: IP address for a port
+        """
+        pass
+
+    @abc.abstractmethod
+    def deallocate_ip(self, context, host, ip):
+        """Revoke IP allocated previously
+        :param host: host/port to have IP address deallocated
+        :param ip: IP address to revoke
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_subnets(self, context, filters=None, fields=None,
+                    sorts=None, limit=None, marker=None,
+                    page_reverse=False):
+        pass
+
+    @abc.abstractmethod
+    def create_network(self, context, network):
+        """Called on network create event
+        :param network: user-supplied network object (dict)
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_network(self, context, network_id):
+        """Called on delete network event
+        :param network_id: UUID of network to be deleted
+        """
+        pass
+
+    @abc.abstractmethod
+    def create_port(self, context, port):
+        """Called on port create event
+        :param port: user-supplied port dict
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_port(self, context, port):
+        """Called on port update event
+        :param port: user-supplied port dict
+        """
+        pass
+
+    @abc.abstractmethod
+    def delete_port(self, context, port):
+        """Called on port delete event
+        :param port: user-supplied port dict
+        """
+        pass
+
+    @abc.abstractmethod
+    def associate_floatingip(self, context, floatingip, port):
+        """Called on floating IP being associated with a port
+        :param floatingip: l3_db.FloatingIP object
+        :param port: models_v2.Port to be associated with floating IP
+        """
+        pass
+
+    @abc.abstractmethod
+    def disassociate_floatingip(self, context, floatingip, port_id):
+        """Inverse of associate floating IP. Removes relationship between
+        floating IP and a port
+        :param floatingip: l3_db.FloatingIP object to be disassociated from
+        port
+        :param port_id: port UUID to be disassociated from floating IP
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_additional_network_dict_params(self, ctx, network_id):
+        """Returns a dict of extra arguments for a network. Place your
+        implementation if neutron agent(s) require extra information to
+        provision DHCP/DNS properly
+        :param network_id: UUID of a network to have extra arguments
+        """
+        pass
diff --git a/neutron/ipam/drivers/__init__.py b/neutron/ipam/drivers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/ipam/drivers/infoblox/__init__.py b/neutron/ipam/drivers/infoblox/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/ipam/drivers/infoblox/config.py b/neutron/ipam/drivers/infoblox/config.py
new file mode 100755
index 0000000..bba27cb
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/config.py
@@ -0,0 +1,617 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import re
+import io
+import logging
+import operator
+
+from oslo.config import cfg as neutron_conf
+
+from neutron.db.infoblox import infoblox_db as ib_db
+from neutron.db.infoblox import models as ib_models
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import nova_manager
+from neutron.ipam.drivers.infoblox import objects
+from neutron.openstack.common import jsonutils
+
+LOG = logging.getLogger(__name__)
+OPTS = [
+    neutron_conf.StrOpt('conditional_config', default=None,
+                        help=_("Infoblox conditional config path")),
+    neutron_conf.StrOpt('infoblox_members_config', default=None,
+                        help=_("Path to infoblox members config file."))
+]
+
+neutron_conf.CONF.register_opts(OPTS)
+
+
+class ConfigFinder(object):
+    """
+    _variable_conditions: contains tenant_id or subnet_range "condition"
+    _static_conditions: contains global or tenant "condition"
+    _assigned_members: contains dhcp members to be registered in db
+                       with its mapping id as network view
+    """
+    VALID_STATIC_CONDITIONS = ['global', 'tenant']
+    VALID_VARIABLE_CONDITIONS = ['tenant_id:', 'subnet_range:']
+    VALID_CONDITIONS = VALID_STATIC_CONDITIONS + VALID_VARIABLE_CONDITIONS
+
+    def __init__(self, stream=None, member_manager=None):
+        """Reads config from `io.IOBase`:stream:. Config is JSON format."""
+        self._member_manager = member_manager
+        self._variable_conditions = []
+        self._static_conditions = []
+        self._assigned_members = dict()
+        self._is_member_registered = False
+
+        if not member_manager:
+            self._member_manager = MemberManager()
+        if not stream:
+            config_file = neutron_conf.CONF.conditional_config
+            if not config_file:
+                raise exceptions.InfobloxConfigException(
+                    msg="Config not found")
+            stream = io.FileIO(config_file)
+
+        with stream:
+            try:
+                self._conf = jsonutils.loads(stream.read())
+                self._read_conditions()
+            except ValueError as e:
+                raise exceptions.InfobloxConfigException(msg=e)
+
+    def configure_members(self, context):
+        # Do this only once after neutron server is restarted
+        if self._is_member_registered:
+            return
+
+        reg_members = self._member_manager.get_registered_members(
+            context)
+
+        # 1. register unregistered members
+        # -------------------------------------------------------
+        reg_member_names = []
+        # if never been registered
+        if len(reg_members) > 0:
+            reg_member_names = map(operator.attrgetter('name'),
+                                   reg_members)
+        reg_member_name_set = set(reg_member_names)
+        conf_member_name_set = set(
+            map(operator.attrgetter('name'),
+                self._member_manager.configured_members)
+        )
+        unreg_member_name_set = conf_member_name_set.difference(
+            reg_member_name_set)
+        self._member_manager.register_members(context,
+                                              list(unreg_member_name_set))
+
+        # 2. reserve the assigned members
+        # -------------------------------------------------------
+        reserv_member_names = []
+        reserv_mapped_ids = []
+        if len(reg_members) > 0:
+            zip_list = zip(*[(m.name, m.map_id)
+                             for m in reg_members if m.map_id])
+            if len(zip_list) == 2:
+                reserv_member_names = list(zip_list[0])
+                reserv_mapped_ids = list(zip_list[1])
+        reserv_member_name_set = set(reserv_member_names)
+
+        for netview, memberset in self._assigned_members.items():
+            if netview in reserv_mapped_ids:
+                continue
+
+            unreserv_member_name_set = memberset.difference(
+                reserv_member_name_set)
+            if len(unreserv_member_name_set) == 0:
+                continue
+
+            member_name = unreserv_member_name_set.pop()
+            self._member_manager.reserve_member(context,
+                                                netview,
+                                                member_name,
+                                                ib_models.DHCP_MEMBER_TYPE)
+            self._member_manager.reserve_member(context,
+                                                netview,
+                                                member_name,
+                                                ib_models.DNS_MEMBER_TYPE)
+
+        self._is_member_registered = True
+
+    def find_config_for_subnet(self, context, subnet):
+        """
+        Returns first configuration which matches the object being created.
+        :param context:
+        :param subnet:
+        :return: :raise exceptions.InfobloxConfigException:
+        """
+        if not self._is_member_registered:
+            self.configure_members(context)
+
+        # First search for matching variable condition
+        for conditions in [self._variable_conditions, self._static_conditions]:
+            for cfg in conditions:
+                cfg = Config(cfg, context, subnet, self._member_manager)
+                if self._condition_matches(context, cfg, subnet):
+                    return cfg
+
+        raise exceptions.InfobloxConfigException(
+            msg="No config found for subnet %s" % subnet)
+
+    def get_all_configs(self, context, subnet):
+        cfgs = []
+        for conditions in [self._variable_conditions, self._static_conditions]:
+            for cfg in conditions:
+                cfg = Config(cfg, context, subnet, self._member_manager)
+                cfgs.append(cfg)
+        return cfgs
+
+    @staticmethod
+    def _variable_condition_match(condition, var, expected):
+        return (condition.startswith(var) and
+                condition.split(':')[1] == expected)
+
+    def _condition_matches(self, context, config, subnet):
+        net_id = subnet.get('network_id', subnet.get('id'))
+        cidr = subnet.get('cidr')
+        tenant_id = subnet['tenant_id']
+
+        is_external = ib_db.is_network_external(context, net_id)
+        cond = config.condition
+        condition_matches = (
+            cond == 'global' or cond == 'tenant' or
+            self._variable_condition_match(cond, 'tenant_id', tenant_id) or
+            self._variable_condition_match(cond, 'subnet_range', cidr))
+
+        return config.is_external == is_external and condition_matches
+
+    def _read_conditions(self):
+        # Define lambdas to check
+        is_static_cond = lambda cond, static_conds: cond in static_conds
+        is_var_cond = lambda cond, var_conds: any([cond.startswith(valid)
+                                                  for valid in var_conds])
+
+        for conf in self._conf:
+            # If condition contain colon: validate it as variable
+            if ':' in conf['condition'] and\
+                is_var_cond(conf['condition'],
+                            self.VALID_VARIABLE_CONDITIONS):
+                self._variable_conditions.append(conf)
+            # If not: validate it as static
+            elif is_static_cond(conf['condition'],
+                                self.VALID_STATIC_CONDITIONS):
+                self._static_conditions.append(conf)
+            # If any of previous checker cannot validate value - rise error
+            else:
+                msg = 'Invalid condition specified: {0}'.format(
+                      conf['condition'])
+                raise exceptions.InfobloxConfigException(msg=msg)
+
+            # Look for assigned member; if dhcp_members list specific
+            # members, then network_view should be static as well
+            netview = conf.get('network_view', 'default')
+            members = conf.get('dhcp_members', Config.NEXT_AVAILABLE_MEMBER)
+            if not isinstance(members, list) and \
+                    members != Config.NEXT_AVAILABLE_MEMBER:
+                members = [members]
+            if isinstance(members, list) and \
+                    not netview.startswith('{'):
+                if self._assigned_members.get(netview):
+                    self._assigned_members[netview].update(set(members))
+                else:
+                    self._assigned_members[netview] = set(members)
+
+
+class PatternBuilder(object):
+    def __init__(self, *pattern):
+        self.pattern = '.'.join([el.strip('.')
+                                 for el in pattern if el is not None])
+
+    def build(self, context, subnet, port=None, ip_addr=None, instance_name=None):
+        """
+        Builds string by passing supplied values into pattern
+        :raise exceptions.InfobloxConfigException:
+        """
+        self._validate_pattern()
+
+        subnet_name = subnet['name'] if subnet['name'] else subnet['id']
+
+        pattern_dict = {
+            'network_id': subnet['network_id'],
+            'network_name': ib_db.get_network_name(context, subnet),
+            'tenant_id': subnet['tenant_id'],
+            'subnet_name': subnet_name,
+            'subnet_id': subnet['id'],
+            'user_id': context.user_id
+        }
+
+        if ip_addr:
+            octets = ip_addr.split('.')
+            ip_addr = ip_addr.replace('.', '-').replace(':', '-')
+            pattern_dict['ip_address'] = ip_addr
+            for i in xrange(len(octets)):
+                octet_key = 'ip_address_octet{i}'.format(i=(i + 1))
+                pattern_dict[octet_key] = octets[i]
+
+        if port:
+            pattern_dict['port_id'] = port['id']
+            pattern_dict['instance_id'] = port['device_id']
+            if instance_name:
+                pattern_dict['instance_name'] = instance_name
+            else:
+                if '{instance_name}' in self.pattern:
+                    nm = nova_manager.NovaManager()
+                    pattern_dict['instance_name'] = nm.get_instance_name_by_id(
+                        port['device_id'])
+
+        try:
+            fqdn = self.pattern.format(**pattern_dict)
+        except (KeyError, IndexError) as e:
+            raise exceptions.InfobloxConfigException(
+                msg="Invalid pattern %s" % e)
+
+        return fqdn
+
+    def _validate_pattern(self):
+        invalid_values = ['..']
+        for val in invalid_values:
+            if val in self.pattern:
+                error_message = "Invalid pattern value {0}".format(val)
+                raise exceptions.InfobloxConfigException(msg=error_message)
+
+
+class Config(object):
+    NEXT_AVAILABLE_MEMBER = '<next-available-member>'
+    NETWORK_VIEW_TEMPLATES = ['{tenant_id}',
+                              '{network_name}',
+                              '{network_id}']
+
+    DEFINING_ATTRS = ['condition', '_dhcp_members', '_dns_members',
+                      '_net_view', '_dns_view']
+
+    def __init__(self, config_dict, context, subnet,
+                 member_manager=None):
+        if not member_manager:
+            _member_manager = MemberManager()
+
+        if 'condition' not in config_dict:
+            raise exceptions.InfobloxConfigException(
+                msg="Missing mandatory 'condition' config option")
+
+        self.condition = config_dict['condition']
+        self.is_external = config_dict.get('is_external', False)
+
+        self._net_view = config_dict.get('network_view', 'default')
+        self._set_network_view_scope()
+
+        self._dns_view = config_dict.get('dns_view', 'default')
+
+        self.require_dhcp_relay = config_dict.get('require_dhcp_relay', False)
+
+        self._dhcp_members = self._members_identifier(
+            config_dict.get('dhcp_members', self.NEXT_AVAILABLE_MEMBER))
+        self._dns_members = self._members_identifier(
+            config_dict.get('dns_members', self._dhcp_members))
+
+        self.domain_suffix_pattern = config_dict.get(
+            'domain_suffix_pattern', 'global.com')
+        self.hostname_pattern = config_dict.get(
+            'hostname_pattern', 'host-{ip_address}.{subnet_name}')
+
+        pattern = re.compile(r'\{\S+\}')
+        if pattern.findall(self.domain_suffix_pattern):
+            self.is_static_domain_suffix = False
+        else:
+            self.is_static_domain_suffix = True
+
+        self.network_template = config_dict.get('network_template')
+        self.ns_group = config_dict.get('ns_group')
+
+        self.context = context
+        self.subnet = subnet
+        self._member_manager = member_manager
+
+    def __eq__(self, other):
+        return (isinstance(other, self.__class__) and
+                all(map(lambda attr:
+                        getattr(self, attr) == getattr(other, attr),
+                        self.DEFINING_ATTRS)))
+
+    def __hash__(self):
+        return hash(tuple(self.DEFINING_ATTRS))
+
+    def __repr__(self):
+        values = {
+            'condition': self.condition,
+            'dns_members': self._dns_members,
+            'dhcp_members': self._dhcp_members,
+            'net_view': self._net_view,
+            'dns_view': self._dns_view
+        }
+
+        return "ConditionalConfig{0}".format(values)
+
+    @property
+    def network_view_scope(self):
+        return self._net_view_scope
+
+    @property
+    def network_view(self):
+        if self._net_view_scope == 'tenant_id':
+            return self.subnet['tenant_id']
+        if self._net_view_scope == 'network_name':
+            return ib_db.get_network_name(self.context, self.subnet)
+        if self._net_view_scope == 'network_id':
+            return self.subnet['network_id']
+        return self._net_view
+
+    @property
+    def dns_view(self):
+        if self.network_view == 'default':
+            return self._dns_view
+
+        return '.'.join([self._dns_view, self.network_view])
+
+    @property
+    def dhcp_members(self):
+        return self._get_members(ib_models.DHCP_MEMBER_TYPE)
+
+    @property
+    def dns_members(self):
+        return self._get_members(ib_models.DNS_MEMBER_TYPE)
+
+    @property
+    def is_global_config(self):
+        return self.condition == 'global'
+
+    def reserve_dns_members(self):
+        reserved_members = self._reserve_members(self._dns_members,
+                                                 self.ns_group,
+                                                 ib_models.DNS_MEMBER_TYPE)
+
+        if isinstance(reserved_members, list):
+            return reserved_members
+        elif reserved_members:
+            return [reserved_members]
+        else:
+            return []
+
+    def reserve_dhcp_members(self):
+        reserved_members = self._reserve_members(self._dhcp_members,
+                                                 self.network_template,
+                                                 ib_models.DHCP_MEMBER_TYPE)
+
+        if isinstance(reserved_members, list):
+            return reserved_members
+        else:
+            return [reserved_members]
+
+    def release_member(self, map_id):
+        self._member_manager.release_member(self.context, map_id)
+
+    def requires_net_view(self):
+        return True
+
+    def verify_subnet_update_is_allowed(self, subnet_new):
+        """
+        Subnet update procedure is not allowed if Infoblox zone name exists on
+        NIOS. This can only happen if domain suffix pattern has subnet name
+        included.
+        """
+        subnet_new_name = subnet_new.get('name')
+        subnet_name = self.subnet.get('name')
+        pattern = self.domain_suffix_pattern
+        update_allowed = not (subnet_name is not None and
+                              subnet_new_name is not None and
+                              subnet_name != subnet_new_name and
+                              '{subnet_name}' in pattern)
+
+        if not update_allowed:
+            raise exceptions.OperationNotAllowed(
+                reason="subnet_name is in domain name pattern")
+
+        if subnet_new.get('network') and subnet_new.get('network_before'):
+            network_new_name = subnet_new.get('network').get('name')
+            network_name = subnet_new.get('network_before').get('name')
+            update_allowed = not (network_name is not None and
+                                  network_new_name is not None and
+                                  network_name != network_new_name and
+                                  '{network_name}' in pattern)
+
+            if not update_allowed:
+                raise exceptions.OperationNotAllowed(
+                    reason="network_name is in domain name pattern")
+
+    def _set_network_view_scope(self):
+        if (self._net_view.startswith('{') and
+                self._net_view not in self.NETWORK_VIEW_TEMPLATES):
+            raise exceptions.InfobloxConfigException(
+                msg="Invalid config value for 'network_view'")
+
+        if self._net_view == '{tenant_id}':
+            self._net_view_scope = 'tenant_id'
+        elif self._net_view == '{network_name}':
+            self._net_view_scope = 'network_name'
+        elif self._net_view == '{network_id}':
+            self._net_view_scope = 'network_id'
+        else:
+            self._net_view_scope = 'static'
+
+    def _get_members(self, member_type):
+        members = self._member_manager.find_members(self.context,
+                                                    self.network_view,
+                                                    member_type)
+        if members:
+            return members
+
+        msg = ("Looks like you're trying to call config.{member_type}_member "
+               "without reserving one. You should call "
+               "reserve_{member_type}_member() "
+               "first!".format(member_type=member_type))
+        raise RuntimeError(msg)
+
+    def _reserve_members_list(self, assigned_members, member_type):
+        members_to_reserve = [self._member_manager.get_member(member)
+                              for member in assigned_members]
+        for member in members_to_reserve:
+            self._member_manager.reserve_member(self.context,
+                                                self.network_view,
+                                                member.name,
+                                                member_type)
+        return members_to_reserve
+
+    def _reserve_by_template(self, assigned_members, template, member_type):
+        member = self._get_member_from_template(assigned_members, template)
+        self._member_manager.reserve_member(self.context,
+                                            self.network_view,
+                                            member.name,
+                                            member_type)
+        return member
+
+    def _reserve_next_avaliable(self, member_type):
+        member = self._member_manager.next_available(self.context,
+                                                     member_type)
+        self._member_manager.reserve_member(self.context,
+                                            self.network_view,
+                                            member.name,
+                                            member_type)
+        return member
+
+    def _reserve_members(self, assigned_members, template, member_type):
+        members = self._member_manager.find_members(self.context,
+                                                    self.network_view,
+                                                    member_type)
+        if members:
+            return members
+
+        if assigned_members == self.NEXT_AVAILABLE_MEMBER:
+            return self._reserve_next_avaliable(member_type)
+        elif isinstance(assigned_members, list):
+            return self._reserve_members_list(assigned_members,
+                                              member_type)
+        elif template:
+            return self._reserve_by_template(assigned_members,
+                                             template,
+                                             member_type)
+
+    def _get_member_from_template(self, assigned_members, template):
+        member_defined = (assigned_members != self.NEXT_AVAILABLE_MEMBER
+                          and isinstance(assigned_members, basestring))
+        if template and not member_defined:
+            msg = 'Member MUST be configured for {template}'.format(
+                template=template)
+            raise exceptions.InfobloxConfigException(msg=msg)
+        return self._member_manager.get_member(assigned_members)
+
+    def _members_identifier(self, members):
+        if not isinstance(members, list) and \
+                members != self.NEXT_AVAILABLE_MEMBER:
+            members = [members]
+        return members
+
+
+class MemberManager(object):
+    def __init__(self, member_config_stream=None):
+        if not member_config_stream:
+            config_file = neutron_conf.CONF.infoblox_members_config
+            if not config_file:
+                raise exceptions.InfobloxConfigException(
+                    msg="Config not found")
+            member_config_stream = io.FileIO(config_file)
+
+        with member_config_stream:
+            all_members = jsonutils.loads(member_config_stream.read())
+
+            try:
+                self.configured_members = map(
+                    lambda m: objects.Member(name=m.get('name'),
+                                             ip=m.get('ipv4addr'),
+                                             ipv6=m.get('ipv6addr'),
+                                             delegate=m.get('delegate'),
+                                             map_id=None),
+                    filter(lambda m: m.get('is_available', True),
+                           all_members))
+            except KeyError as key:
+                raise exceptions.InfobloxConfigException(
+                    msg="Invalid member config key: %s" % key)
+
+        if self.configured_members is None or \
+                len(self.configured_members) == 0:
+            raise exceptions.InfobloxConfigException(
+                msg="Configured member not found")
+
+    def __repr__(self):
+        values = {
+            'configured_members': self.configured_members
+        }
+        return "MemberManager{0}".format(values)
+
+    def register_members(self, context, member_names):
+        for member_name in member_names:
+            ib_db.register_member(context, None, member_name,
+                                  ib_models.DHCP_MEMBER_TYPE)
+            ib_db.register_member(context, None, member_name,
+                                  ib_models.DNS_MEMBER_TYPE)
+
+    def get_registered_members(self, context,
+                               member_type=ib_models.DHCP_MEMBER_TYPE):
+        registered_members = ib_db.get_registered_members(context,
+                                                          member_type)
+        members = []
+        for reg_member in registered_members:
+            for member in self.configured_members:
+                if member.name == reg_member.member_name:
+                    member.map_id = reg_member.map_id
+                    members.append(member)
+        return members
+
+    def next_available(self, context, member_type):
+        avail_member = ib_db.get_available_member(context, member_type)
+        if not avail_member:
+            raise exceptions.InfobloxConfigException(
+                msg="No infoblox member available")
+
+        return self.get_member(avail_member.member_name)
+
+    def reserve_member(self, context, mapping, member_name, member_type):
+        ib_db.attach_member(context, mapping, member_name, member_type)
+
+    def release_member(self, context, mapping):
+        ib_db.release_member(context, mapping)
+
+    def get_member(self, member_name):
+        for member in self.configured_members:
+            if member.name == member_name:
+                return member
+        raise exceptions.InfobloxConfigException(
+            msg="No infoblox member available")
+
+    def find_members(self, context, map_id, member_type):
+        existing_members = ib_db.get_members(context, map_id, member_type)
+        if not existing_members:
+            return []
+
+        members = []
+        for existing_member in existing_members:
+            for member in self.configured_members:
+                if member.name == existing_member.member_name:
+                    members.append(member)
+
+        if not members:
+            msg = "Reserved member not available in config"
+            raise exceptions.InfobloxConfigException(msg=msg)
+
+        return members
diff --git a/neutron/ipam/drivers/infoblox/connector.py b/neutron/ipam/drivers/infoblox/connector.py
new file mode 100755
index 0000000..aaa168f
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/connector.py
@@ -0,0 +1,357 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import functools
+import re
+
+from oslo.config import cfg
+import requests
+from requests import exceptions as req_exc
+import urllib
+import urlparse
+
+from neutron.ipam.drivers.infoblox import exceptions as exc
+from neutron.openstack.common import jsonutils
+from neutron.openstack.common import log as logging
+
+
+OPTS = [
+    cfg.StrOpt('infoblox_wapi', help=_("REST API url")),
+    cfg.StrOpt('infoblox_username', help=_("User name")),
+    cfg.StrOpt('infoblox_password', help=_("User password")),
+    cfg.BoolOpt('infoblox_sslverify', default=False),
+    cfg.IntOpt('infoblox_http_pool_connections', default=100),
+    cfg.IntOpt('infoblox_http_pool_maxsize', default=100),
+    cfg.IntOpt('infoblox_http_request_timeout', default=120)
+]
+
+cfg.CONF.register_opts(OPTS)
+
+
+LOG = logging.getLogger(__name__)
+
+
+def reraise_neutron_exception(func):
+    @functools.wraps(func)
+    def callee(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except req_exc.Timeout as e:
+            LOG.error(e.message)
+            raise exc.InfobloxTimeoutError(e)
+        except req_exc.RequestException as e:
+            LOG.error(_("HTTP request failed: %s"), e)
+            raise exc.InfobloxConnectionError(reason=e)
+    return callee
+
+
+class Infoblox(object):
+    """
+    Infoblox class
+
+    Defines methods for getting, creating, updating and
+    removing objects from an Infoblox server instance.
+    """
+
+    CLOUD_WAPI_MAJOR_VERSION = 2
+
+    def __init__(self):
+        """
+        Initialize a new Infoblox object instance
+        Args:
+            config (str): Path to the Infoblox configuration file
+        """
+        self.wapi = cfg.CONF.infoblox_wapi
+        self.username = cfg.CONF.infoblox_username
+        self.password = cfg.CONF.infoblox_password
+        self.sslverify = cfg.CONF.infoblox_sslverify
+        self.request_timeout = cfg.CONF.infoblox_http_request_timeout
+
+        if not self.wapi or not self.username or not self.password:
+            raise exc.InfobloxIsMisconfigured()
+
+        self.is_cloud = self.is_cloud_wapi(self.wapi)
+        self.session = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=cfg.CONF.infoblox_http_pool_connections,
+            pool_maxsize=cfg.CONF.infoblox_http_pool_maxsize)
+        self.session.mount('http://', adapter)
+        self.session.mount('https://', adapter)
+        self.session.auth = (self.username, self.password)
+        self.session.verify = self.sslverify
+
+    @staticmethod
+    def is_cloud_wapi(wapi_url):
+        version_match = re.search('\/wapi\/v(\d+)\.(\d+)', wapi_url)
+        if version_match:
+            if int(version_match.group(1)) >= Infoblox.CLOUD_WAPI_MAJOR_VERSION:
+                return True
+        return False
+
+    def _construct_url(self, relative_path, query_params=None, extattrs=None):
+        if query_params is None:
+            query_params = {}
+        if extattrs is None:
+            extattrs = {}
+
+        if not relative_path or relative_path[0] == '/':
+            raise ValueError('Path in request must be relative.')
+        query = ''
+        if query_params or extattrs:
+            query = '?'
+
+        if extattrs:
+            attrs_queries = []
+            for key, value in extattrs.items():
+                attrs_queries.append('*' + key + '=' + value['value'])
+            query += '&'.join(attrs_queries)
+        if query_params:
+            if len(query) > 1:
+                query += '&'
+            query += urllib.urlencode(query_params)
+
+        baseurl = urlparse.urljoin(self.wapi, urllib.quote(relative_path))
+        return baseurl + query
+
+    @staticmethod
+    def _validate_objtype_or_die(objtype, objtype_expected=True):
+        if not objtype:
+            raise ValueError('WAPI object type can\'t be empty.')
+        if objtype_expected and '/' in objtype:
+            raise ValueError('WAPI object type can\'t contain slash.')
+
+    @reraise_neutron_exception
+    def get_object(self, objtype, payload=None, return_fields=None,
+                   extattrs=None, proxy=False):
+        """
+        Retrieve a list of Infoblox objects of type 'objtype'
+        Args:
+            objtype  (str): Infoblox object type, e.g. 'network', 
+                            'range', etc.
+            payload (dict): Payload with data to send
+            return_fields (list): List of fields to be returned
+            extattrs      (list): List of Extensible Attributes
+        Returns:
+            A list of the Infoblox objects requested
+        Raises:
+            InfobloxObjectNotFound
+        """
+        if return_fields is None:
+            return_fields = []
+        if extattrs is None:
+            extattrs = {}
+
+        self._validate_objtype_or_die(objtype, objtype_expected=False)
+
+        query_params = dict()
+        if payload:
+            query_params = payload
+
+        if return_fields:
+            query_params['_return_fields'] = ','.join(return_fields)
+
+        # Some get requests like 'ipv4address' should be always
+        # proxied to GM on Hellfire
+        # If request is cloud and proxy is not forced yet,
+        # then plan to do 2 request:
+        # - the first one is not proxified to GM
+        # - the second is proxified to GM
+        urls = dict()
+        urls['direct'] = self._construct_url(objtype, query_params, extattrs)
+        if self.is_cloud:
+            query_params['_proxy_search'] = 'GM'
+            urls['proxy'] = self._construct_url(objtype, query_params, extattrs)
+
+        url = urls['direct']
+        if self.is_cloud and proxy:
+            url = urls['proxy']
+
+        headers = {'Content-type': 'application/json'}
+
+        ib_object = self._get_object(objtype, url, headers)
+        if ib_object:
+            return ib_object
+
+        # if cloud api and proxy is not used, use proxy
+        if self.is_cloud and not proxy:
+            return self._get_object(objtype, urls['proxy'], headers)
+
+        return None
+
+    def _get_object(self, objtype, url, headers):
+        r = self.session.get(url,
+                             verify=self.sslverify,
+                             timeout=self.request_timeout,
+                             headers=headers)
+
+        if r.status_code == requests.codes.UNAUTHORIZED:
+            raise exc.InfobloxBadWAPICredential(response='')
+
+        if r.status_code != requests.codes.ok:
+            raise exc.InfobloxSearchError(
+                response=jsonutils.loads(r.content),
+                objtype=objtype,
+                content=r.content,
+                code=r.status_code)
+
+        return jsonutils.loads(r.content)
+
+    @reraise_neutron_exception
+    def create_object(self, objtype, payload,
+                     return_fields=None,  delegate_member=None):
+        """
+        Create an Infoblox object of type 'objtype'
+        Args:
+            objtype        (str): Infoblox object type,
+                                  e.g. 'network', 'range', etc.
+            payload       (dict): Payload with data to send
+            return_fields (list): List of fields to be returned
+        Returns:
+            The object reference of the newly create object
+        Raises:
+            InfobloxException
+        """
+        if self.is_cloud and delegate_member and delegate_member.delegate:
+            payload.update({"cloud_info": {
+                    "delegated_member": delegate_member.specifier}})
+
+        if not return_fields:
+            return_fields = []
+
+        self._validate_objtype_or_die(objtype)
+
+        query_params = dict()
+
+        if return_fields:
+            query_params['_return_fields'] = ','.join(return_fields)
+
+        url = self._construct_url(objtype, query_params)
+        data = jsonutils.dumps(payload)
+        headers = {'Content-type': 'application/json'}
+        r = self.session.post(url,
+                              data=data,
+                              verify=self.sslverify,
+                              timeout=self.request_timeout,
+                              headers=headers)
+
+        if r.status_code == requests.codes.UNAUTHORIZED:
+            raise exc.InfobloxBadWAPICredential(response='')
+
+        if r.status_code != requests.codes.CREATED:
+            raise exc.InfobloxCannotCreateObject(
+                response=jsonutils.loads(r.content),
+                objtype=objtype,
+                content=r.content,
+                args=payload,
+                code=r.status_code)
+
+        return jsonutils.loads(r.content)
+
+    @reraise_neutron_exception
+    def call_func(self, func_name, ref, payload, return_fields=None):
+        if not return_fields:
+            return_fields = []
+
+        query_params = dict()
+        query_params['_function'] = func_name
+
+        if return_fields:
+            query_params['_return_fields'] = ','.join(return_fields)
+
+        url = self._construct_url(ref, query_params)
+
+        headers = {'Content-type': 'application/json'}
+        r = self.session.post(url,
+                              data=jsonutils.dumps(payload),
+                              verify=self.sslverify,
+                              headers=headers)
+
+        if r.status_code == requests.codes.UNAUTHORIZED:
+            raise exc.InfobloxBadWAPICredential(response='')
+
+        if r.status_code not in (requests.codes.CREATED,
+                                 requests.codes.ok):
+            raise exc.InfobloxFuncException(
+                response=jsonutils.loads(r.content),
+                ref=ref,
+                func_name=func_name,
+                content=r.content,
+                code=r.status_code)
+
+        return jsonutils.loads(r.content)
+
+    @reraise_neutron_exception
+    def update_object(self, ref, payload, return_fields=None):
+        """
+        Update an Infoblox object
+        Args:
+            ref      (str): Infoblox object reference
+            payload (dict): Payload with data to send
+        Returns:
+            The object reference of the updated object
+        Raises:
+            InfobloxException
+        """
+        query_params = {}
+        if return_fields:
+            query_params['_return_fields'] = ','.join(return_fields)
+
+        headers = {'Content-type': 'application/json'}
+        r = self.session.put(self._construct_url(ref, query_params),
+                             data=jsonutils.dumps(payload),
+                             verify=self.sslverify,
+                             timeout=self.request_timeout,
+                             headers=headers)
+
+        if r.status_code == requests.codes.UNAUTHORIZED:
+            raise exc.InfobloxBadWAPICredential(response='')
+
+        if r.status_code != requests.codes.ok:
+            raise exc.InfobloxCannotUpdateObject(
+                response=jsonutils.loads(r.content),
+                ref=ref,
+                content=r.content,
+                code=r.status_code)
+
+        return jsonutils.loads(r.content)
+
+    @reraise_neutron_exception
+    def delete_object(self, ref):
+        """
+        Remove an Infoblox object
+        Args:
+            ref      (str): Object reference
+        Returns:
+            The object reference of the removed object
+        Raises:
+            InfobloxException
+        """
+        r = self.session.delete(self._construct_url(ref),
+                                verify=self.sslverify,
+                                timeout=self.request_timeout)
+
+        if r.status_code == requests.codes.UNAUTHORIZED:
+            raise exc.InfobloxBadWAPICredential(response='')
+
+        if r.status_code != requests.codes.ok:
+            raise exc.InfobloxCannotDeleteObject(
+                response=jsonutils.loads(r.content),
+                ref=ref,
+                content=r.content,
+                code=r.status_code)
+
+        return jsonutils.loads(r.content)
diff --git a/neutron/ipam/drivers/infoblox/constants.py b/neutron/ipam/drivers/infoblox/constants.py
new file mode 100644
index 0000000..cef4cea
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/constants.py
@@ -0,0 +1,31 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+from neutron.common import constants as neutron_constants
+from neutron.plugins.common import constants as plugins_constants
+
+NEUTRON_DEVICE_OWNER_TO_PATTERN_MAP = {
+    neutron_constants.DEVICE_OWNER_DHCP: 'dhcp-port-{ip_address}',
+    neutron_constants.DEVICE_OWNER_ROUTER_INTF: 'router-iface-{ip_address}',
+    neutron_constants.DEVICE_OWNER_ROUTER_GW: 'router-gw-{ip_address}',
+    neutron_constants.DEVICE_OWNER_FLOATINGIP: 'floating-ip-{ip_address}',
+    'neutron:' + plugins_constants.LOADBALANCER: 'lb-vip-{ip_address}',
+}
+
+NEUTRON_INTERNAL_SERVICE_DEVICE_OWNERS = [
+    neutron_constants.DEVICE_OWNER_DHCP,
+    neutron_constants.DEVICE_OWNER_ROUTER_INTF,
+    neutron_constants.DEVICE_OWNER_ROUTER_GW,
+    'neutron:' + plugins_constants.LOADBALANCER
+]
diff --git a/neutron/ipam/drivers/infoblox/dns_controller.py b/neutron/ipam/drivers/infoblox/dns_controller.py
new file mode 100755
index 0000000..e8130ea
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/dns_controller.py
@@ -0,0 +1,308 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import re
+from oslo.config import cfg as neutron_conf
+from taskflow.patterns import linear_flow
+
+from neutron.common import constants as neutron_constants
+from neutron.db.infoblox import infoblox_db as infoblox_db
+from neutron.common import ipv6_utils
+from neutron.ipam.drivers.infoblox import config
+from neutron.ipam.drivers.infoblox import connector
+from neutron.ipam.drivers.infoblox import constants as ib_constants
+from neutron.ipam.drivers.infoblox import ea_manager
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import object_manipulator
+from neutron.ipam.drivers.infoblox import tasks
+from neutron.ipam.drivers import neutron_ipam
+from neutron.openstack.common import log as logging
+
+OPTS = [
+    neutron_conf.StrOpt('private_dns_view_name',
+                        default=None,
+                        help=_("If single_network_view_name is specified, "
+                               "this option will define DNS View name used "
+                               "to serve networks from the single network "
+                               "view. Otherwise it is ignored and "
+                               "'default.<netview_name>' is used.")),
+    neutron_conf.StrOpt('external_dns_view_name',
+                        default=None,
+                        help=_("All the subnets created in external networks "
+                               "will be associated with DNS View with such "
+                               "name. If not specified, name "
+                               "'default.<netview_name>' will be used.")),
+    neutron_conf.StrOpt('subnet_fqdn_suffix',
+                        default='com',
+                        help=_("Suffix for subnet domain name. Used to "
+                               "generate subnet FQDN which is built using "
+                               "the following pattern "
+                               "<subnet_domain><subnet_fqdn_suffix>. "
+                               "Subnet domain uniquely represents subnet and "
+                               "equal to subnet name if specified, otherwise "
+                               "equal to the first part of subnet uuid.")),
+    neutron_conf.BoolOpt('use_global_dns_zone',
+                         default=True,
+                         help=_("Use global DNS zone. Global private DNS zone "
+                                "only make sense when we use single network "
+                                "view")),
+    neutron_conf.BoolOpt('allow_admin_network_deletion',
+                         default=False,
+                         help=_("Allow admin network which is global, "
+                                "external, or shared to be deleted"))
+]
+
+LOG = logging.getLogger(__name__)
+neutron_conf.CONF.register_opts(OPTS)
+
+
+class InfobloxDNSController(neutron_ipam.NeutronDNSController):
+
+    SUBDOMAIN_NAME_LEN = 8
+
+    def __init__(self, ip_allocator, manipulator=None, config_finder=None):
+        super(InfobloxDNSController, self).__init__()
+
+        if not manipulator:
+            manipulator = object_manipulator.InfobloxObjectManipulator(
+                connector.Infoblox())
+
+        self.infoblox = manipulator
+        self.ip_allocator = ip_allocator
+        self.config_finder = config_finder
+        self.ea_manager = ea_manager.InfobloxEaManager(infoblox_db)
+        self.pattern_builder = config.PatternBuilder
+
+    def disassociate_floatingip(self, context, ip_address, port_id):
+        floating_port_id = ip_address.get('floating_port_id')
+        port = infoblox_db.get_port_by_id(context, floating_port_id)
+        extattrs = self.ea_manager.get_extattrs_for_ip(context, port, True)
+        self.bind_names(context, port, disassociate=True)
+
+    @staticmethod
+    def get_hostname_pattern(port, cfg, instance_name):
+        port_owner = port['device_owner']
+        if port_owner == neutron_constants.DEVICE_OWNER_FLOATINGIP:
+            if instance_name and "{instance_name}" in cfg.hostname_pattern:
+                return cfg.hostname_pattern
+        if (port_owner
+                in ib_constants.NEUTRON_DEVICE_OWNER_TO_PATTERN_MAP.keys()):
+            return ib_constants.NEUTRON_DEVICE_OWNER_TO_PATTERN_MAP[port_owner]
+        else:
+            return cfg.hostname_pattern
+
+    @staticmethod
+    def get_instancename(extattrs):
+        instance_name = None
+        if extattrs:
+            vm_attr = extattrs.get('VM Name')
+            if vm_attr:
+                instance_name = vm_attr.get('value')
+        return instance_name
+
+    def _bind_names(self, context, backend_port, binding_func, extattrs=None):
+        all_dns_members = []
+
+        for ip in backend_port['fixed_ips']:
+            subnet = infoblox_db.get_subnet(context, ip['subnet_id'])
+            if subnet['ip_version'] == 4 or \
+                    not ipv6_utils.is_auto_address_subnet(subnet):
+                cfg = self.config_finder.find_config_for_subnet(context,
+                                                                subnet)
+                dns_members = cfg.reserve_dns_members()
+                all_dns_members.extend(dns_members)
+                ip_addr = ip['ip_address']
+                instance_name = self.get_instancename(extattrs)
+
+                hostname_pattern = self.get_hostname_pattern(
+                                            backend_port, cfg, instance_name)
+                pattern_builder = self.pattern_builder(
+                                hostname_pattern, cfg.domain_suffix_pattern)
+                fqdn = pattern_builder.build(
+                    context, subnet, backend_port, ip_addr, instance_name)
+
+                binding_func(cfg.network_view, cfg.dns_view, ip_addr, fqdn,
+                             extattrs)
+
+        for member in set(all_dns_members):
+            self.infoblox.restart_all_services(member)
+
+    def bind_names(self, context, backend_port, disassociate=False):
+        if not backend_port['device_owner']:
+            return
+        # In the case of disassociating floatingip, we need to explicitly
+        # indicate to ignore instance id associated with the floating ip.
+        # This is because, at this point, the floating ip is still associated
+        # with instance in the neutron database.
+        extattrs = self.ea_manager.get_extattrs_for_ip(
+                        context, backend_port, ignore_instance_id=disassociate)
+        try:
+            self._bind_names(context, backend_port,
+                             self.ip_allocator.bind_names, extattrs)
+        except exceptions.InfobloxCannotCreateObject as e:
+            self.unbind_names(context, backend_port)
+            raise e
+
+    def unbind_names(self, context, backend_port):
+        self._bind_names(context, backend_port, self.ip_allocator.unbind_names)
+
+    def create_dns_zones(self, context, backend_subnet):
+        cfg = self.config_finder.find_config_for_subnet(context,
+                                                        backend_subnet)
+        dns_members = cfg.reserve_dns_members()
+
+        dns_zone = self.pattern_builder(cfg.domain_suffix_pattern).\
+            build(context, backend_subnet)
+        zone_extattrs = self.ea_manager.get_extattrs_for_zone(
+            context, subnet=backend_subnet)
+
+        # Add prefix only for classless networks (ipv4)
+        # mask greater than 24 needs prefix.
+        # use meaningful prefix if used
+        prefix = None
+        if backend_subnet['ip_version'] == 4:
+            m = re.search(r'/\d+', backend_subnet['cidr'])
+            mask = m.group().replace("/", "")
+            if int(mask) > 24:
+                if len(backend_subnet['name']) > 0:
+                    prefix = backend_subnet['name']
+                else:
+                    prefix = '-'.join(
+                        filter(None,
+                               re.split(r'[.:/]', backend_subnet['cidr']))
+                    )
+
+        args = {
+            'backend_subnet': backend_subnet,
+            'dnsview_name': cfg.dns_view,
+            'fqdn': dns_zone,
+            'cidr': backend_subnet['cidr'],
+            'prefix': prefix,
+            'zone_format': 'IPV%s' % backend_subnet['ip_version'],
+            'zone_extattrs': zone_extattrs,
+            'obj_manip': self.infoblox
+        }
+        create_dns_zones_flow = linear_flow.Flow('create-dns-zones')
+
+        if cfg.ns_group:
+            args['ns_group'] = cfg.ns_group
+            create_dns_zones_flow.add(
+                tasks.CreateDNSZonesFromNSGroupTask(),
+                tasks.CreateDNSZonesCidrFromNSGroupTask(),
+            )
+        else:
+            args['dns_member'] = dns_members[0]
+            args['secondary_dns_members'] = dns_members[1:]
+            create_dns_zones_flow.add(
+                tasks.CreateDNSZonesTask(),
+                tasks.CreateDNSZonesTaskCidr())
+
+        context.store.update(args)
+        context.parent_flow.add(create_dns_zones_flow)
+
+    def delete_dns_zones(self, context, backend_subnet):
+        cfg = self.config_finder.find_config_for_subnet(context,
+                                                        backend_subnet)
+        dns_zone_fqdn = self.pattern_builder(cfg.domain_suffix_pattern).\
+            build(context, backend_subnet)
+        dnsview_name = cfg.dns_view
+
+        network = self._get_network(context, backend_subnet['network_id'])
+        is_external = infoblox_db.is_network_external(context,
+                                                      network.get('id'))
+        is_shared = network.get('shared')
+
+        # If config is global, do not delete dns zone for that subnet
+        # If subnet is for external or shared network, do not delete a zone
+        #   for the subnet.
+        # If subnet is for private network (not external, shared, or global),
+        #   check if domain suffix is unique to the subnet.
+        #     if subnet name is part of the domain suffix pattern, then delete
+        #       forward zone.
+        #     if network name is part of the domain suffix pattern, then delete
+        #       forward zone only if the subnet is only remaining subnet
+        #       in the network.
+        # Reverse zone is deleted when not global, not external, and not shared
+        if neutron_conf.CONF.allow_admin_network_deletion or \
+                not (cfg.is_global_config or is_external or is_shared):
+            if (('{subnet_name}' in cfg.domain_suffix_pattern or
+                    '{subnet_id}' in cfg.domain_suffix_pattern) or
+                (('{network_name}' in cfg.domain_suffix_pattern or
+                    '{network_id}' in cfg.domain_suffix_pattern) and
+                    infoblox_db.is_last_subnet_in_network(
+                        context, backend_subnet['id'],
+                        backend_subnet['network_id'])) or
+                ('{tenant_id}' in cfg.domain_suffix_pattern and
+                    infoblox_db.is_last_subnet_in_tenant(
+                        context, backend_subnet['id'],
+                        backend_subnet['tenant_id'])) or
+                (self._determine_static_zone_deletion(
+                    context, backend_subnet,
+                    cfg.is_static_domain_suffix))):
+                # delete forward zone
+                self.infoblox.delete_dns_zone(dnsview_name, dns_zone_fqdn)
+
+            # delete reverse zone
+            self.infoblox.delete_dns_zone(dnsview_name,
+                                          backend_subnet['cidr'])
+
+    def _determine_static_zone_deletion(self, context,
+                                        backend_subnet, is_static):
+        """
+        Checking config if deletion is possible:
+            global tenant
+               x     x       n/a
+               o     x       cannot delete, global cannot be deleted
+               x     o       allow delete, only tenant should use
+               o     o       cannot delete, global cannot be deleted
+        If possible, then subnet must be the last one among all private
+        networks.
+        """
+        if not is_static:
+            return False
+
+        cfgs = self.config_finder.get_all_configs(context, backend_subnet)
+        for cfg in cfgs:
+            if cfg.is_global_config and cfg.is_static_domain_suffix:
+                return False
+
+        return infoblox_db.is_last_subnet_in_private_networks(
+            context, backend_subnet['id'])
+
+
+def has_nameservers(subnet):
+    try:
+        has_dns = iter(subnet['dns_nameservers']) is not None
+    except (TypeError, KeyError):
+        has_dns = False
+
+    return has_dns
+
+
+def get_nameservers(subnet):
+    if has_nameservers(subnet):
+        return subnet['dns_nameservers']
+    return []
+
+
+def build_fqdn(prefix, zone, ip_address):
+    ip_address = ip_address.replace('.', '-')
+    if zone:
+        zone.lstrip('.')
+    return "%(prefix)s%(ip_address)s.%(zone)s" % {
+        'prefix': prefix,
+        'ip_address': ip_address,
+        'zone': zone
+    }
diff --git a/neutron/ipam/drivers/infoblox/ea_manager.py b/neutron/ipam/drivers/infoblox/ea_manager.py
new file mode 100755
index 0000000..42fd79f
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/ea_manager.py
@@ -0,0 +1,329 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from oslo.config import cfg
+
+from neutron.db import db_base_plugin_v2
+from neutron.db import l3_db
+from neutron.db import models_v2
+from neutron.ipam.drivers.infoblox import connector
+from neutron.ipam.drivers.infoblox import constants as ib_constants
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import l2_driver
+from neutron.ipam.drivers.infoblox import nova_manager
+from neutron.openstack.common import log as logging
+
+
+LOG = logging.getLogger(__name__)
+
+
+class InfobloxEaManager(object):
+    # CMP == cloud management platform
+    OPENSTACK_OBJECT_FLAG = 'CMP Type'
+
+    def __init__(self, infoblox_db):
+        # Passing this thru constructor to avoid cyclic imports
+        self.db = infoblox_db
+        self._network_l2_info_provider = l2_driver.L2Info()
+
+    def get_extattrs_for_nview(self, context):
+        """
+        Generates EAs for Network View
+        :param context: current neutron context
+        :return: dict with extensible attributes ready to be sent as part of
+        NIOS WAPI
+        """
+        os_tenant_id = context.tenant_id
+
+        attributes = {
+            'Tenant ID': os_tenant_id,
+            # OpenStack should not own entire network view,
+            # since shared or external networks may be created in it
+            'Cloud API Owned': False,
+        }
+        return self._build_extattrs(attributes)
+
+    def get_extattrs_for_network(self, context, subnet=None, network=None):
+        """
+        Sets non-null values from subnet and network to corresponding EAs in
+        NIOS
+        :param context: current neutron context
+        :param subnet: neutron subnet object
+        :param network: neutron network object
+        :return: dict with extensible attributes ready to be sent as part of
+        NIOS WAPI
+        """
+        if subnet is None:
+            subnet = {}
+        if network is None:
+            network = {}
+
+        os_subnet_id = subnet.get('id')
+        os_subnet_name = subnet.get('name')
+
+        os_network_id = network.get('id')
+        os_network_name = network.get('name')
+        os_network_l2_info = self._network_l2_info_provider.\
+            get_network_l2_info(context.session, os_network_id)
+        os_network_type = os_network_l2_info.get('network_type').upper()
+
+        os_segmentation_id = os_network_l2_info.get('segmentation_id')
+        os_physical_network = os_network_l2_info.get('physical_network')
+        os_tenant_id = (network.get('tenant_id') or
+                        subnet.get('tenant_id') or
+                        context.get('tenant_id'))
+        os_user_id = context.user_id
+
+        attributes = {
+            'Subnet ID': os_subnet_id,
+            'Subnet Name': os_subnet_name,
+            'Network ID': os_network_id,
+            'Network Name': os_network_name,
+            'Network Encap': os_network_type,
+            'Segmentation ID': os_segmentation_id,
+            'Physical Network Name': os_physical_network,
+            'Tenant ID': os_tenant_id,
+            'Account': os_user_id,
+        }
+
+        # set clowd_api_owned, is_external, is_shared from common routine
+        common_ea = self._get_common_ea(context, subnet, network)
+        attributes.update(common_ea)
+
+        return self._build_extattrs(attributes)
+
+    def get_extattrs_for_range(self, context, network):
+        os_user_id = context.user_id
+        os_tenant_id = context.tenant_id
+        common_ea = self._get_common_ea(context, network=network)
+
+        attributes = {
+            'Tenant ID': os_tenant_id,
+            'Account': os_user_id,
+            'Cloud API Owned': common_ea['Cloud API Owned'],
+        }
+        return self._build_extattrs(attributes)
+
+    def get_default_extattrs_for_ip(self, context):
+        attributes = {
+            'Tenant ID': context.tenant_id,
+            'Account': context.user_id,
+            'Port ID': None,
+            'Port Attached Device - Device Owner': None,
+            'Port Attached Device - Device ID': None,
+            'Cloud API Owned': True,
+            'IP Type': 'Fixed',
+            'VM ID': None,
+            'VM Name': None
+        }
+        return self._build_extattrs(attributes)
+
+    def get_extattrs_for_ip(self, context, port, ignore_instance_id=False):
+        # Fallback to 'None' as string since NIOS requires this value to be set
+        os_tenant_id = port.get('tenant_id') or context.tenant_id or 'None'
+        os_user_id = context.user_id
+
+        neutron_internal_services_dev_owners = \
+            ib_constants.NEUTRON_INTERNAL_SERVICE_DEVICE_OWNERS
+
+        # for gateway ip, no instance id exists
+        os_instance_id = None
+        os_instance_name = None
+
+        set_os_instance_id = ((not ignore_instance_id) and
+                              (port['device_owner'] not in
+                               neutron_internal_services_dev_owners))
+
+        if set_os_instance_id:
+            # for floating ip, no instance id exists
+            os_instance_id = self._get_instance_id(context, port)
+            if os_instance_id:
+                nm = nova_manager.NovaManager()
+                os_instance_name = nm.get_instance_name_by_id(os_instance_id)
+
+        network = self.db.get_network(context, port['network_id'])
+        common_ea = self._get_common_ea(context, network=network)
+
+        attributes = {
+            'Tenant ID': os_tenant_id,
+            'Account': os_user_id,
+            'Port ID': port['id'],
+            'Port Attached Device - Device Owner': port['device_owner'],
+            'Port Attached Device - Device ID': port['device_id'],
+            'Cloud API Owned': common_ea['Cloud API Owned'],
+            'VM ID': os_instance_id,
+            'VM Name': os_instance_name,
+        }
+
+        if self.db.is_network_external(context, port['network_id']):
+            attributes['IP Type'] = 'Floating'
+        else:
+            attributes['IP Type'] = 'Fixed'
+
+        return self._build_extattrs(attributes)
+
+    def get_extattrs_for_zone(self, context, subnet=None, network=None):
+        os_user_id = context.user_id
+        os_tenant_id = context.tenant_id
+        common_ea = self._get_common_ea(context, subnet=subnet, network=None)
+
+        attributes = {
+            'Tenant ID': os_tenant_id,
+            'Account': os_user_id,
+            'Cloud API Owned': common_ea['Cloud API Owned'],
+        }
+        return self._build_extattrs(attributes)
+
+    def _get_common_ea(self, context, subnet=None, network=None):
+        if hasattr(subnet, 'external'):
+            os_network_is_external = subnet.get('external')
+        elif network:
+            os_network_is_external = self.db.is_network_external(
+                context, network.get('id'))
+        else:
+            os_network_is_external = False
+
+        if network:
+            os_network_is_shared = network.get('shared')
+        else:
+            os_network_is_shared = False
+
+        os_cloud_owned = not (os_network_is_external or os_network_is_shared)
+        attributes = {
+            'Is External': os_network_is_external,
+            'Is Shared': os_network_is_shared,
+            'Cloud API Owned': os_cloud_owned,
+        }
+        return attributes
+
+    def _get_instance_id(self, context, port):
+        is_floatingip = port['device_owner'] == l3_db.DEVICE_OWNER_FLOATINGIP
+
+        if is_floatingip:
+            os_instance_id = self.db.get_instance_id_by_floating_ip(
+                context, floating_ip_id=port['device_id'])
+        else:
+            os_instance_id = port['device_id']
+
+        return os_instance_id
+
+    @staticmethod
+    def _to_str_or_none(value):
+        retval = None
+        if not isinstance(value, basestring):
+            if value is not None:
+                retval = str(value)
+        else:
+            retval = value
+        return retval
+
+    def _build_extattrs(self, attributes):
+        extattrs = {}
+        for name, value in attributes.iteritems():
+            str_val = self._to_str_or_none(value)
+            if str_val:
+                extattrs[name] = {'value': str_val}
+
+        self.add_openstack_extattrs_marker(extattrs)
+        return extattrs
+
+    @classmethod
+    def add_openstack_extattrs_marker(cls, extattrs):
+        extattrs[cls.OPENSTACK_OBJECT_FLAG] = {'value': 'OpenStack'}
+
+
+def _construct_extattrs(filters):
+    extattrs = {}
+    for name, filter_value_list in filters.items():
+        # Filters in Neutron look like a dict
+        # {
+        #   'filter1_name': ['filter1_value'],
+        #   'filter2_name': ['filter2_value']
+        # }
+        # So we take only the first item from user's input which is
+        # filter_value_list here.
+        # Also not Infoblox filters must be removed from filters.
+        # Infoblox filters must be as following:
+        # neutron <command> --infoblox_ea:<EA_name> <EA_value>
+        infoblox_prefix = 'infoblox_ea:'
+        if name.startswith(infoblox_prefix) and filter_value_list:
+            # "infoblox-ea:" removed from filter name
+            prefix_len = len(infoblox_prefix)
+            attr_name = name[prefix_len:]
+            extattrs[attr_name] = {'value': filter_value_list[0]}
+    return extattrs
+
+
+def _extattrs_result_filter_hook(query, filters, db_model,
+                                 os_object, ib_objtype, mapping_id):
+    """Result filter hook which filters Infoblox objects by
+     Extensible Attributes (EAs) and returns Query object containing
+     OpenStack objects which are equal to Infoblox ones.
+    """
+    infoblox = connector.Infoblox()
+    infoblox_objects_ids = []
+    extattrs = _construct_extattrs(filters)
+
+    if extattrs:
+        InfobloxEaManager.add_openstack_extattrs_marker(extattrs)
+        infoblox_objects = infoblox.get_object(
+            ib_objtype, return_fields=['extattrs'],
+            extattrs=extattrs)
+        if infoblox_objects:
+            for infoblox_object in infoblox_objects:
+                try:
+                    obj_id = infoblox_object['extattrs'][mapping_id]['value']
+                except KeyError:
+                    raise exceptions.NoAttributeInInfobloxObject(
+                        os_object=os_object, ib_object=ib_objtype,
+                        attribute=mapping_id)
+                infoblox_objects_ids.append(obj_id)
+        query = query.filter(db_model.id.in_(infoblox_objects_ids))
+    return query
+
+
+def subnet_extattrs_result_filter_hook(query, filters):
+    return _extattrs_result_filter_hook(
+        query, filters, models_v2.Subnet, 'subnet', 'network', 'Subnet ID')
+
+
+def network_extattrs_result_filter_hook(query, filters):
+    return _extattrs_result_filter_hook(
+        query, filters, models_v2.Network, 'subnet', 'network',
+        'Network ID')
+
+
+def port_extattrs_result_filter_hook(query, filters):
+    if cfg.CONF.use_host_records_for_ip_allocation:
+        ib_objtype = 'record:host'
+    else:
+        ib_objtype = 'record:a'
+    return _extattrs_result_filter_hook(
+        query, filters, models_v2.Port, 'port', ib_objtype, 'Port ID')
+
+
+if (cfg.CONF.ipam_driver ==
+        'neutron.ipam.drivers.infoblox.infoblox_ipam.InfobloxIPAM'):
+    db_base_plugin_v2.NeutronDbPluginV2.register_model_query_hook(
+        models_v2.Network, 'network_extattrs', None, None,
+        network_extattrs_result_filter_hook)
+
+    db_base_plugin_v2.NeutronDbPluginV2.register_model_query_hook(
+        models_v2.Subnet, 'subnet_extattrs', None, None,
+        subnet_extattrs_result_filter_hook)
+
+    db_base_plugin_v2.NeutronDbPluginV2.register_model_query_hook(
+        models_v2.Port, 'port_extattrs', None, None,
+        port_extattrs_result_filter_hook)
diff --git a/neutron/ipam/drivers/infoblox/exceptions.py b/neutron/ipam/drivers/infoblox/exceptions.py
new file mode 100755
index 0000000..abe1762
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/exceptions.py
@@ -0,0 +1,125 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from neutron.common import exceptions
+
+
+class InfobloxException(exceptions.NeutronException):
+    """Generic Infoblox Exception."""
+    def __init__(self, response, **kwargs):
+        self.response = response
+        super(InfobloxException, self).__init__(**kwargs)
+
+
+class InfobloxIsMisconfigured(exceptions.NeutronException):
+    message = _("Infoblox IPAM is misconfigured: infoblox_wapi, "
+                "infoblox_username and infoblox_password must be defined.")
+
+
+class InfobloxSearchError(InfobloxException):
+    message = _("Cannot search '%(objtype)s' object(s): "
+                "%(content)s [code %(code)s]")
+
+
+class InfobloxCannotCreateObject(InfobloxException):
+    message = _("Cannot create '%(objtype)s' object(s): "
+                "%(content)s [code %(code)s]")
+
+
+class InfobloxCannotDeleteObject(InfobloxException):
+    message = _("Cannot delete object with ref %(ref)s: "
+                "%(content)s [code %(code)s]")
+
+
+class InfobloxCannotUpdateObject(InfobloxException):
+    message = _("Cannot update object with ref %(ref)s: "
+                "%(content)s [code %(code)s]")
+
+
+class InfobloxFuncException(InfobloxException):
+    message = _("Error occured during function's '%(func_name)s' call: "
+                "ref %(ref)s: %(content)s [code %(code)s]")
+
+
+class InfobloxHostRecordIpAddrNotCreated(exceptions.NeutronException):
+    message = _("Infoblox host record ipv4addr/ipv6addr has not been "
+                "created for IP %(ip)s, mac %(mac)s")
+
+
+
+class InfobloxCannotAllocateIpForSubnet(exceptions.NeutronException):
+    message = _("Infoblox Network view %(netview)s, Network %(cidr)s "
+                "does not have IPs available for allocation.")
+
+
+class InfobloxCannotAllocateIp(exceptions.NeutronException):
+    message = _("Cannot allocate IP %(ip_data)s")
+
+
+class InfobloxDidNotReturnCreatedIPBack(exceptions.NeutronException):
+    message = _("Infoblox did not return created IP back")
+
+
+class InfobloxNetworkNotAvailable(exceptions.NeutronException):
+    message = _("No network view %(net_view_name)s for %(cidr)s")
+
+
+class InfobloxObjectParsingError(exceptions.NeutronException):
+    message = _("Infoblox object cannot be parsed from dict: %(data)s")
+
+
+class HostRecordNotPresent(InfobloxObjectParsingError):
+    message = _("Cannot parse Host Record object from dict because "
+                "'ipv4addrs'/'ipv6addrs' is absent.")
+
+
+class InfobloxInvalidIp(InfobloxObjectParsingError):
+    message = _("Bad IP address: %(ip)s")
+
+
+class NoAttributeInInfobloxObject(exceptions.NeutronException):
+    message = _("To find OpenStack %(os_object)s for Infoblox %(ib_object)s, "
+                "%(attribute)s must be in extensible attributes.")
+
+
+class OperationNotAllowed(exceptions.NeutronException):
+    message = _("Requested operation is not allowed: %(reason)s")
+
+
+class InfobloxConnectionError(exceptions.NeutronException):
+    message = _("Infoblox HTTP request failed with: %(reason)s")
+
+
+class InfobloxConfigException(exceptions.NeutronException):
+    """Generic Infoblox Config Exception."""
+    message = _("Config error: %(msg)s")
+
+
+class InfobloxInternalPrivateSubnetAlreadyExist(exceptions.Conflict):
+    message = _("Network with the same CIDR already exists on NIOS.")
+
+
+class InfobloxNetworkTypeNotAllowed(InfobloxException):
+    message = _("Network with network_type '%(network_type)s' "
+                "not allowed by NIOS.")
+
+
+class InfobloxBadWAPICredential(InfobloxException):
+    message = _("Infoblox IPAM is misconfigured: "
+                "infoblox_username and infoblox_password are incorrect.")
+
+
+class InfobloxTimeoutError(InfobloxException):
+    message = _("Connection to NIOS timed out")
diff --git a/neutron/ipam/drivers/infoblox/infoblox_ipam.py b/neutron/ipam/drivers/infoblox/infoblox_ipam.py
new file mode 100755
index 0000000..e0f6456
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/infoblox_ipam.py
@@ -0,0 +1,92 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import taskflow.engines
+from taskflow.patterns import linear_flow
+
+from neutron.db.infoblox import models
+from neutron.ipam.drivers.infoblox import config
+from neutron.ipam.drivers.infoblox import connector
+from neutron.ipam.drivers.infoblox import dns_controller
+from neutron.ipam.drivers.infoblox import ip_allocator
+from neutron.ipam.drivers.infoblox import ipam_controller
+from neutron.ipam.drivers.infoblox import object_manipulator
+from neutron.ipam.drivers import neutron_ipam
+
+
+class FlowContext(object):
+    def __init__(self, neutron_context, flow_name):
+        self.parent_flow = linear_flow.Flow(flow_name)
+        self.context = neutron_context
+        self.store = {}
+
+    def __getattr__(self, item):
+        return getattr(self.context, item)
+
+
+class InfobloxIPAM(neutron_ipam.NeutronIPAM):
+    def __init__(self):
+        super(InfobloxIPAM, self).__init__()
+
+        config_finder = config.ConfigFinder()
+        obj_manipulator = object_manipulator.InfobloxObjectManipulator(
+            connector=connector.Infoblox())
+        ip_alloc = ip_allocator.get_ip_allocator(obj_manipulator)
+
+        self.ipam_controller = ipam_controller.InfobloxIPAMController(
+            config_finder=config_finder,
+            obj_manip=obj_manipulator,
+            ip_allocator=ip_alloc)
+
+        self.dns_controller = dns_controller.InfobloxDNSController(
+            config_finder=config_finder,
+            manipulator=obj_manipulator,
+            ip_allocator=ip_alloc
+        )
+
+    def create_subnet(self, context, subnet):
+        context = FlowContext(context, 'create-subnet')
+        context.store['subnet'] = subnet
+        retval = super(InfobloxIPAM, self).create_subnet(context, subnet)
+        taskflow.engines.run(context.parent_flow, store=context.store)
+        return retval
+
+    def _collect_members_ips(self, context, network_id, model):
+        members = context.session.query(model)
+        result = members.filter_by(network_id=network_id)
+        ip_list = []
+        ipv6_list = []
+        for member in result:
+            ip_list.append(member.server_ip)
+            ipv6_list.append(member.server_ipv6)
+        return (ip_list, ipv6_list)
+
+    def get_additional_network_dict_params(self, ctx, network_id):
+        dns_list, dns_ipv6_list = self._collect_members_ips(
+            ctx, network_id, models.InfobloxDNSMember)
+
+        dhcp_list, dhcp_ipv6_list = self._collect_members_ips(
+            ctx, network_id, models.InfobloxDHCPMember)
+
+        ib_mgmt_ip = self.ipam_controller.ib_db.get_management_net_ip(
+            ctx, network_id)
+
+        return {
+            'external_dhcp_servers': dhcp_list,
+            'external_dns_servers': dns_list,
+            'external_dhcp_ipv6_servers': dhcp_ipv6_list,
+            'external_dns_ipv6_servers': dns_ipv6_list,
+            'mgmt_iface_ip': ib_mgmt_ip
+        }
diff --git a/neutron/ipam/drivers/infoblox/ip_allocator.py b/neutron/ipam/drivers/infoblox/ip_allocator.py
new file mode 100755
index 0000000..13178ff
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/ip_allocator.py
@@ -0,0 +1,180 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import abc
+
+from oslo.config import cfg
+from neutron.openstack.common import log as logging
+from neutron.common import constants as neutron_constants
+import six
+
+
+OPTS = [
+    cfg.ListOpt('bind_dns_records_to_fixed_address',
+                default=[],
+                help=_("List of DNS records to bind to "
+                       "Fixed Address during create_port")),
+    cfg.ListOpt('unbind_dns_records_from_fixed_address',
+                default=[],
+                help=_("List of DNS records to unbind from "
+                       "Fixed Address during delete_port. "
+                       "This is typically the same list as "
+                       "that for "
+                       "bind_resource_records_to_fixedaddress")),
+    cfg.ListOpt('delete_dns_records_associated_with_fixed_address',
+                default=[],
+                help=_("List of associated DNS records to delete "
+                       "when a Fixed Address is deleted. This is "
+                       "typically a list of DNS records created "
+                       "independent of the Infoblox Openstack "
+                       "Adaptor (IOA)"))
+]
+
+cfg.CONF.register_opts(OPTS)
+LOG = logging.getLogger(__name__)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class IPAllocator(object):
+
+    def __init__(self, infoblox):
+        self.infoblox = infoblox
+
+    @abc.abstractmethod
+    def allocate_ip_from_range(self, dnsview_name, networkview_name, zone_auth,
+                               hostname, mac, first_ip, last_ip,
+                               extattrs=None):
+        pass
+
+    @abc.abstractmethod
+    def allocate_given_ip(self, netview_name, dnsview_name, zone_auth,
+                          hostname, mac, ip, extattrs=None):
+        pass
+
+    @abc.abstractmethod
+    def deallocate_ip(self, network_view, dns_view_name, ip):
+        pass
+
+    @abc.abstractmethod
+    def bind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        pass
+
+    @abc.abstractmethod
+    def unbind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        pass
+
+
+class HostRecordIPAllocator(IPAllocator):
+    def bind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        # See OPENSTACK-181. In case hostname already exists on NIOS, update
+        # host record which contains that hostname with the new IP address
+        # rather than creating a separate host record object
+        reserved_hostname_hr = self.infoblox.find_hostname(dnsview_name,
+                                                           name, ip)
+        reserved_ip_hr = self.infoblox.get_host_record(dnsview_name, ip)
+
+        if reserved_hostname_hr == reserved_ip_hr:
+            return
+        if reserved_hostname_hr:
+            for hr_ip in reserved_ip_hr.ips:
+                if hr_ip == ip:
+                    self.infoblox.delete_host_record(dnsview_name, ip)
+                    self.infoblox.add_ip_to_record(reserved_hostname_hr,
+                                                   ip,
+                                                   hr_ip.mac)
+                    break
+        else:
+            self.infoblox.bind_name_with_host_record(dnsview_name, ip,
+                                                     name, extattrs)
+
+    def unbind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        # Nothing to delete, all will be deleted together with host record.
+        pass
+
+    def allocate_ip_from_range(self, dnsview_name, networkview_name,
+                               zone_auth, hostname, mac, first_ip, last_ip,
+                               extattrs=None):
+        fqdn = hostname + '.' + zone_auth
+        host_record = self.infoblox.find_hostname(dnsview_name, fqdn,
+                                                  first_ip)
+        if host_record:
+            hr = self.infoblox.add_ip_to_host_record_from_range(
+                host_record, networkview_name, mac, first_ip, last_ip)
+        else:
+            hr = self.infoblox.create_host_record_from_range(
+                dnsview_name, networkview_name, zone_auth, hostname, mac,
+                first_ip, last_ip, extattrs)
+        return hr.ips[-1].ip
+
+    def allocate_given_ip(self, netview_name, dnsview_name, zone_auth,
+                          hostname, mac, ip, extattrs=None):
+        hr = self.infoblox.create_host_record_for_given_ip(
+            dnsview_name, zone_auth, hostname, mac, ip, extattrs)
+        return hr.ips[-1].ip
+
+    def deallocate_ip(self, network_view, dns_view_name, ip):
+        host_record = self.infoblox.get_host_record(dns_view_name, ip)
+
+        if host_record and len(host_record.ips) > 1:
+            self.infoblox.delete_ip_from_host_record(host_record, ip)
+        else:
+            self.infoblox.delete_host_record(dns_view_name, ip)
+
+
+class FixedAddressIPAllocator(IPAllocator):
+    def bind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        bind_cfg = cfg.CONF.bind_dns_records_to_fixed_address
+        if extattrs.get('Port Attached Device - Device Owner').\
+                get('value') == neutron_constants.DEVICE_OWNER_FLOATINGIP:
+            self.infoblox.update_fixed_address_eas(netview_name, ip,
+                                                   extattrs)
+            self.infoblox.update_dns_record_eas(dnsview_name, ip,
+                                                extattrs)
+        if bind_cfg:
+            self.infoblox.bind_name_with_record_a(
+                dnsview_name, ip, name, bind_cfg, extattrs)
+
+    def unbind_names(self, netview_name, dnsview_name, ip, name, extattrs):
+        unbind_cfg = cfg.CONF.unbind_dns_records_from_fixed_address
+        if unbind_cfg:
+            self.infoblox.unbind_name_from_record_a(
+                dnsview_name, ip, name, unbind_cfg)
+
+    def allocate_ip_from_range(self, dnsview_name, networkview_name,
+                               zone_auth, hostname, mac, first_ip, last_ip,
+                               extattrs=None):
+        fa = self.infoblox.create_fixed_address_from_range(
+            networkview_name, mac, first_ip, last_ip, extattrs)
+        return fa.ip
+
+    def allocate_given_ip(self, netview_name, dnsview_name, zone_auth,
+                          hostname, mac, ip, extattrs=None):
+        fa = self.infoblox.create_fixed_address_for_given_ip(
+            netview_name, mac, ip, extattrs)
+        return fa.ip
+
+    def deallocate_ip(self, network_view, dns_view_name, ip):
+        delete_cfg = cfg.CONF.delete_dns_records_associated_with_fixed_address
+        if delete_cfg:
+            self.infoblox.delete_all_associated_objects(
+                network_view, ip, delete_cfg)
+        self.infoblox.delete_fixed_address(network_view, ip)
+
+
+def get_ip_allocator(obj_manipulator):
+    if cfg.CONF.use_host_records_for_ip_allocation:
+        return HostRecordIPAllocator(obj_manipulator)
+    else:
+        return FixedAddressIPAllocator(obj_manipulator)
diff --git a/neutron/ipam/drivers/infoblox/ipam_controller.py b/neutron/ipam/drivers/infoblox/ipam_controller.py
new file mode 100755
index 0000000..4ac87a2
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/ipam_controller.py
@@ -0,0 +1,420 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from oslo.config import cfg as neutron_conf
+from taskflow.patterns import linear_flow
+
+from neutron.api.v2 import attributes
+from neutron.db.infoblox import infoblox_db
+from neutron.db.infoblox import models
+from neutron.ipam.drivers.infoblox import config
+from neutron.ipam.drivers.infoblox import dns_controller
+from neutron.ipam.drivers.infoblox import ea_manager
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import tasks
+from neutron.ipam.drivers import neutron_db
+from neutron.ipam.drivers import neutron_ipam
+from neutron.openstack.common import log as logging
+from neutron.openstack.common import uuidutils
+
+
+OPTS = [
+    neutron_conf.BoolOpt('use_host_records_for_ip_allocation',
+                         default=True,
+                         help=_("Use host records for IP allocation. "
+                                "If False then Fixed IP + A + PTR record "
+                                "are used.")),
+    neutron_conf.StrOpt('dhcp_relay_management_network_view',
+                        default="default",
+                        help=_("NIOS network view to be used for DHCP inside "
+                                "management network")),
+    neutron_conf.StrOpt('dhcp_relay_management_network',
+                        default=None,
+                        help=_("CIDR for the management network served by "
+                               "Infoblox DHCP member")),
+    neutron_conf.BoolOpt('allow_admin_network_deletion',
+                         default=False,
+                         help=_("Allow admin network which is global, "
+                                "external, or shared to be deleted"))
+]
+
+neutron_conf.CONF.register_opts(OPTS)
+LOG = logging.getLogger(__name__)
+
+
+class InfobloxIPAMController(neutron_ipam.NeutronIPAMController):
+    def __init__(self, obj_manip=None, config_finder=None, ip_allocator=None,
+                 extattr_manager=None, ib_db=None, db_mgr=None):
+        """IPAM backend implementation for Infoblox."""
+        self.infoblox = obj_manip
+        self.config_finder = config_finder
+        self.ip_allocator = ip_allocator
+        self.pattern_builder = config.PatternBuilder
+
+        if extattr_manager is None:
+            extattr_manager = ea_manager.InfobloxEaManager(infoblox_db)
+
+        if db_mgr is None:
+            db_mgr = neutron_db
+
+        self.db_manager = db_mgr
+        self.ea_manager = extattr_manager
+
+        if ib_db is None:
+            ib_db = infoblox_db
+
+        self.ib_db = ib_db
+
+    def create_subnet(self, context, s):
+        subnet = super(InfobloxIPAMController, self).create_subnet(context, s)
+
+        cfg = self.config_finder.find_config_for_subnet(context, subnet)
+        dhcp_members = cfg.reserve_dhcp_members()
+        dns_members = cfg.reserve_dns_members()
+
+        network = self._get_network(context, subnet['network_id'])
+        create_infoblox_member = True
+
+        create_subnet_flow = linear_flow.Flow('ib_create_subnet')
+
+        if self.infoblox.network_exists(cfg.network_view, subnet['cidr']):
+            create_subnet_flow.add(tasks.ChainInfobloxNetworkTask())
+            create_infoblox_member = False
+
+        if not infoblox_db.get_network_view(context, subnet['network_id']):
+            infoblox_db.set_network_view(context, cfg.network_view,
+                                         subnet['network_id'])
+
+        # Neutron will sort this later so make sure infoblox copy is
+        # sorted too.
+        user_nameservers = sorted(dns_controller.get_nameservers(s))
+
+        # For flat network we save member IP as a primary DNS server: to
+        # the beginning of the list.
+        # If this net is not flat, Member IP will later be replaced by
+        # DNS relay IP.
+        nameservers = [item.ipv6 if subnet['ip_version'] == 6
+                                 else item.ip for item in dns_members]
+
+        nameservers += [n for n in user_nameservers if n not in nameservers]
+
+        nview_extattrs = self.ea_manager.get_extattrs_for_nview(context)
+        network_extattrs = self.ea_manager.get_extattrs_for_network(
+            context, subnet, network)
+        range_extattrs = self.ea_manager.get_extattrs_for_range(
+            context, network)
+        method_arguments = {
+            'obj_manip':        self.infoblox,
+            'net_view_name':    cfg.network_view,
+            'dns_view_name':    cfg.dns_view,
+            'cidr':             subnet['cidr'],
+            'dhcp_member':      dhcp_members,
+            'gateway_ip':       subnet['gateway_ip'],
+            'disable':          True,
+            'nameservers':      nameservers,
+            'range_extattrs':   range_extattrs,
+            'network_extattrs': network_extattrs,
+            'nview_extattrs':   nview_extattrs,
+            'related_members':  set(cfg.dhcp_members + cfg.dns_members),
+            'dhcp_trel_ip':     infoblox_db.get_management_net_ip(
+                context, subnet['network_id']),
+            'ip_version':       subnet['ip_version']
+        }
+
+        if subnet['ip_version'] == 6 and subnet['enable_dhcp']:
+            if attributes.is_attr_set(subnet.get('ipv6_ra_mode')):
+                method_arguments['ipv6_ra_mode'] = subnet['ipv6_ra_mode']
+            if attributes.is_attr_set(subnet.get('ipv6_address_mode')):
+                method_arguments[
+                    'ipv6_address_mode'] = subnet['ipv6_address_mode']
+
+        if cfg.require_dhcp_relay:
+            for member in dhcp_members:
+                dhcp_member = models.InfobloxDHCPMember(
+                    server_ip=member.ip,
+                    server_ipv6=member.ipv6,
+                    network_id=network.id
+                )
+                context.session.add(dhcp_member)
+
+            for member in dns_members:
+                dns_member = models.InfobloxDNSMember(
+                    server_ip=member.ip,
+                    server_ipv6=member.ipv6,
+                    network_id=network.id
+                )
+                context.session.add(dns_member)
+
+        if cfg.requires_net_view():
+            create_subnet_flow.add(tasks.CreateNetViewTask())
+
+        if cfg.network_template:
+            method_arguments['template'] = cfg.network_template
+            create_subnet_flow.add(tasks.CreateNetworkFromTemplateTask())
+        elif create_infoblox_member:
+            create_subnet_flow.add(tasks.CreateNetworkTask())
+
+        create_subnet_flow.add(tasks.CreateDNSViewTask())
+
+        for ip_range in subnet['allocation_pools']:
+            # context.store is a global dict of method arguments for tasks
+            # in current flow, hence method arguments need to be rebound
+            first = ip_range['start']
+            last = ip_range['end']
+            first_ip_arg = 'ip_range %s' % first
+            last_ip_arg = 'ip_range %s' % last
+            method_arguments[first_ip_arg] = first
+            method_arguments[last_ip_arg] = last
+            task_name = '-'.join([first, last])
+
+            create_subnet_flow.add(
+                tasks.CreateIPRange(name=task_name,
+                                    rebind={'start_ip': first_ip_arg,
+                                            'end_ip': last_ip_arg}))
+
+        context.store.update(method_arguments)
+        context.parent_flow.add(create_subnet_flow)
+
+        return subnet
+
+    def update_subnet(self, context, subnet_id, subnet):
+        backend_subnet = self.get_subnet_by_id(context, subnet_id)
+        cfg = self.config_finder.find_config_for_subnet(context,
+                                                        backend_subnet)
+        cfg.verify_subnet_update_is_allowed(subnet)
+
+        ib_network = self.infoblox.get_network(cfg.network_view,
+                                               subnet['cidr'])
+
+        user_nameservers = sorted(subnet.get('dns_nameservers', []))
+        updated_nameservers = user_nameservers
+        if (ib_network.member_ip_addrs and
+                ib_network.member_ip_addrs[0] in ib_network.dns_nameservers):
+            # Flat network, primary dns is member_ip
+            primary_dns = ib_network.member_ip_addrs[0]
+            updated_nameservers = [primary_dns] + user_nameservers
+        else:
+            # Network with relays, primary dns is relay_ip
+            primary_dns = self.ib_db.get_subnet_dhcp_port_address(
+                context, subnet['id'])
+            if primary_dns:
+                updated_nameservers = [primary_dns] + user_nameservers
+
+        ib_network.dns_nameservers = updated_nameservers
+
+        network = self._get_network(context, subnet['network_id'])
+        eas = self.ea_manager.get_extattrs_for_network(context, subnet,
+                                                       network)
+        self.infoblox.update_network_options(ib_network, eas)
+
+        self.restart_services(context, subnet=subnet)
+        return backend_subnet
+
+    def delete_subnet(self, context, subnet):
+        deleted_subnet = super(InfobloxIPAMController, self).delete_subnet(
+            context, subnet)
+
+        cfg = self.config_finder.find_config_for_subnet(context, subnet)
+        network = self._get_network(context, subnet['network_id'])
+        members_to_restart = list(set(cfg.dhcp_members + cfg.dns_members))
+        is_shared = network.get('shared')
+        is_external = infoblox_db.is_network_external(context,
+                                                      subnet['network_id'])
+
+        if neutron_conf.CONF.allow_admin_network_deletion or \
+            not (cfg.is_global_config or is_shared or is_external):
+            self.infoblox.delete_network(
+                cfg.network_view, cidr=subnet['cidr'])
+
+        if self._determine_member_deletion(context,
+                                           cfg.network_view_scope,
+                                           subnet['id'],
+                                           subnet['network_id'],
+                                           subnet['tenant_id']):
+            cfg.release_member(cfg.network_view)
+
+        if cfg.require_dhcp_relay and \
+            self.ib_db.is_last_subnet_in_network(context, subnet['id'],
+                                                 subnet['network_id']):
+                member = context.session.query(models.InfobloxDNSMember)
+                member.filter_by(network_id=network.id).delete()
+
+                member = context.session.query(models.InfobloxDHCPMember)
+                member.filter_by(network_id=network.id).delete()
+
+        preconf_dns_view = cfg._dns_view
+        if (preconf_dns_view and not preconf_dns_view.startswith('default')
+                and not self.infoblox.has_dns_zones(preconf_dns_view)):
+            self.infoblox.delete_dns_view(preconf_dns_view)
+
+        self.restart_services(context, members=members_to_restart)
+        return deleted_subnet
+
+    def _determine_member_deletion(self, context, network_view_scope,
+                                   subnet_id, network_id, tenant_id):
+        if network_view_scope == 'static':
+            return self.ib_db.is_last_subnet(context, subnet_id)
+        if network_view_scope == 'tenant_id':
+            return self.ib_db.is_last_subnet_in_tenant(context,
+                                                       subnet_id,
+                                                       tenant_id)
+        if network_view_scope == 'network_id':
+            return self.ib_db.is_last_subnet_in_network(context,
+                                                        subnet_id,
+                                                        network_id)
+        # In order to use network_name scope, a network name must be unique.
+        # Openstack does not enforce this so user has to make sure that
+        # each network name is unique when {network_name} pattern is used
+        # for network view name. Then this is the same as network_id scope.
+        if network_view_scope == 'network_name':
+            return self.ib_db.is_last_subnet_in_network(context,
+                                                        subnet_id,
+                                                        network_id)
+
+    def allocate_ip(self, context, subnet, port, ip=None):
+        hostname = uuidutils.generate_uuid()
+        mac = port['mac_address']
+        extattrs = self.ea_manager.get_extattrs_for_ip(context, port)
+
+        LOG.debug("Trying to allocate IP for %s on Infoblox NIOS" % hostname)
+
+        cfg = self.config_finder.find_config_for_subnet(context, subnet)
+
+        networkview_name = cfg.network_view
+        dnsview_name = cfg.dns_view
+        zone_auth = self.pattern_builder(cfg.domain_suffix_pattern).build(
+            context, subnet)
+
+        if ip and ip.get('ip_address', None):
+            subnet_id = ip.get('subnet_id', None)
+            ip_to_be_allocated = ip.get('ip_address', None)
+            allocated_ip = self.ip_allocator.allocate_given_ip(
+                networkview_name, dnsview_name, zone_auth, hostname, mac,
+                ip_to_be_allocated, extattrs)
+            allocated_ip = {'subnet_id': subnet_id,
+                            'ip_address': allocated_ip}
+        else:
+            # Allocate next available considering IP ranges.
+            ip_ranges = subnet['allocation_pools']
+            # Let Infoblox try to allocate an IP from each ip_range
+            # consistently, and break on the first successful allocation.
+            for ip_range in ip_ranges:
+                first_ip = ip_range['first_ip']
+                last_ip = ip_range['last_ip']
+                try:
+                    allocated_ip = self.ip_allocator.allocate_ip_from_range(
+                        dnsview_name, networkview_name, zone_auth, hostname,
+                        mac, first_ip, last_ip, extattrs)
+                    allocated_ip = {'subnet_id': subnet['id'],
+                                    'ip_address': allocated_ip}
+
+                    break
+                except exceptions.InfobloxCannotAllocateIp:
+                    LOG.debug("Failed to allocate IP from range (%s-%s)." %
+                              (first_ip, last_ip))
+                    continue
+            else:
+                # We went through all the ranges and Infoblox did not
+                # allocated any IP.
+                LOG.debug("Network %s does not have IPs "
+                          "available for allocation." % subnet['cidr'])
+                return None
+
+        LOG.debug('IP address allocated on Infoblox NIOS: %s', allocated_ip)
+
+        for member in set(cfg.dhcp_members):
+            self.infoblox.restart_all_services(member)
+
+        return allocated_ip
+
+    def deallocate_ip(self, context, subnet, port, ip):
+        cfg = self.config_finder.find_config_for_subnet(context, subnet)
+        net_id = subnet['network_id']
+        self.ip_allocator.deallocate_ip(cfg.network_view, cfg.dns_view, ip)
+        self.ib_db.delete_ip_allocation(context, net_id, subnet, ip)
+
+        for member in set(cfg.dhcp_members):
+            self.infoblox.restart_all_services(member)
+
+    def set_dns_nameservers(self, context, port):
+        # Replace member IP in DNS nameservers by DNS relay IP.
+        for ip in port['fixed_ips']:
+            subnet = self._get_subnet(context, ip['subnet_id'])
+            cfg = self.config_finder.find_config_for_subnet(context, subnet)
+            net = self.infoblox.get_network(cfg.network_view, subnet['cidr'])
+            if not net.members:
+                continue
+            if not net.has_dns_members():
+                LOG.debug("No domain-name-servers option found, it will"
+                          "not be updated to the private IPAM relay IP.")
+                continue
+            net.update_member_ip_in_dns_nameservers(ip['ip_address'])
+            self.infoblox.update_network_options(net)
+
+    def create_network(self, context, network):
+        if not neutron_conf.CONF.dhcp_relay_management_network:
+            LOG.info(_('dhcp_relay_management_network option is not set in '
+                       'config. DHCP will be used for management network '
+                       'interface.'))
+            return network
+
+        net_view_name = neutron_conf.CONF.dhcp_relay_management_network_view
+        cidr = neutron_conf.CONF.dhcp_relay_management_network
+        mac = ':'.join(['00'] * 6)
+
+        # Note(pbondar): If IP is allocated for dhcp relay (trel interface)
+        # when dhcp relay management network is set,
+        # OpenStack is unware of this so no port to associate with.
+        # In this case, we still need to populate EAs with default values.
+        ip_extattrs = self.ea_manager.get_default_extattrs_for_ip(context)
+        created_fixed_address = self.infoblox.create_fixed_address_from_cidr(
+            net_view_name, mac, cidr, ip_extattrs)
+
+        self.ib_db.add_management_ip(context,
+                                     network['id'],
+                                     created_fixed_address)
+        return network
+
+    def delete_network(self, context, network_id):
+        subnets = self.db_manager.get_subnets_by_network(context, network_id)
+        net_view = infoblox_db.get_network_view(context, network_id)
+
+        for subnet in subnets:
+            LOG.info('Removing subnet %s from network %s.' % (
+                subnet.id, network_id
+            ))
+            self.delete_subnet(context, subnet)
+
+        if net_view and not self.infoblox.has_networks(net_view):
+            self.infoblox.delete_network_view(net_view)
+
+        fixed_address_ref = self.ib_db.get_management_ip_ref(context,
+                                                             network_id)
+
+        if fixed_address_ref is not None:
+            self.infoblox.delete_object_by_ref(fixed_address_ref)
+            self.ib_db.delete_management_ip(context, network_id)
+
+    def restart_services(self, context, members=None, subnet=None):
+        if not members:
+            members = []
+
+        if subnet:
+            cfg = self.config_finder.find_config_for_subnet(context, subnet)
+            for member in set(cfg.dhcp_members + cfg.dns_members):
+                members.append(member)
+
+        for member in set(members):
+            self.infoblox.restart_all_services(member)
diff --git a/neutron/ipam/drivers/infoblox/l2_driver.py b/neutron/ipam/drivers/infoblox/l2_driver.py
new file mode 100644
index 0000000..83ab633
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/l2_driver.py
@@ -0,0 +1,140 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import abc
+import re
+import six
+
+from oslo.config import cfg
+
+from neutron.openstack.common import importutils
+from neutron.openstack.common import log as logging
+
+LOG = logging.getLogger(__name__)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class L2DriverBase(object):
+    """Defines interface for retreiving info from L2 pluings.
+    L2 Driver should:
+       - be located under 'l2_drivers' directory;
+       - have name {core_plugin_name}.py;
+       - have class name 'Driver';
+       - be inherited from this class;
+       - implement methods which are marked as abstractmethods;
+    """
+    @abc.abstractmethod
+    def init_driver(self):
+        """Should be implemented in driver for L2 plugin.
+        This method should import needed L2 plugin and
+        store reference to it somewhere in self.
+        So any import exception should be raised at this point.
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_network_binding(self, session, network_id):
+        """Should be implemented in driver for L2 plugin.
+        :param session: database session object
+        :param network_id: network id
+         """
+        pass
+
+    def __init__(self):
+        """No need to override this in child.
+        Just inits L2 modules for now.
+        """
+        self.init_driver()
+
+
+class L2Info(object):
+    """This class provides network info from L2 plugins
+    using factory of facades.
+    """
+    def __init__(self, core_plugin=None):
+        """
+        :param: core_plugin: OpenStack core plugin
+        will be loaded from config if not provided
+        """
+        if not core_plugin:
+            core_plugin = cfg.CONF.core_plugin
+        self.core_plugin = core_plugin
+        self.driver = None
+
+    def _get_driver(self):
+        """Return Driver for L2 plugin.
+        Loads appropriate module if not loaded yet.
+        """
+        if not self.driver:
+            self.driver = L2DriverFactory.load(self.core_plugin)
+        return self.driver
+
+    def get_network_l2_info(self, session, network_id):
+        """Decorator/wrapper method for get_network_binding()
+        Converts network info from L2Driver(list format) into
+        dict with fixed keys.
+        :param session: database session object
+        :param network_id: network id
+        """
+        segments = None
+        l2_info = {'network_type': None,
+                   'segmentation_id': None,
+                   'physical_network': None}
+
+        driver = self._get_driver()
+        segments = driver.get_network_binding(session, network_id)
+
+        if segments:
+            for name, value in segments.iteritems():
+                l2_info[name] = value
+
+        return l2_info
+
+
+class L2DriverFactory(object):
+    """This class loads Driver for L2 plugin
+    depending on L2 core_plugin class name.
+    """
+
+    @classmethod
+    def load(cls, core_plugin):
+        """Loads driver for core_plugin
+        """
+        driver_prefix = 'neutron.ipam.drivers.infoblox.l2_drivers.'
+        driver_postfix = '.Driver'
+        # Look for infoblox driver for core plugin
+        plugin_name = cls.get_plugin_name(core_plugin)
+        driver = driver_prefix + plugin_name + driver_postfix
+        LOG.info(_("Loading driver %s for core plugin"), driver)
+        # Try to load driver, generates exception if fails
+        driver_class = importutils.import_class(driver)
+        return driver_class()
+
+    @classmethod
+    def get_plugin_name(cls, core_plugin):
+        """Returns plugin name based on plugin path.
+        Plugin name can be found on position number three in path
+        neutron.plugins.{plugin_name}.(path_to_module)
+        """
+        plugin = str(core_plugin)
+        match = re.match(r'^neutron\.plugins\.([a-zA-Z0-9_]+)\.',
+                         plugin)
+        if match:
+            return match.group(1)
+
+        # if plugin doesn't match, assume core_plugin is short name
+        # instead of full path to module.
+        # See examples of full path / short name in setup.cfg
+        return plugin
diff --git a/neutron/ipam/drivers/infoblox/l2_drivers/__init__.py b/neutron/ipam/drivers/infoblox/l2_drivers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/ipam/drivers/infoblox/l2_drivers/ml2.py b/neutron/ipam/drivers/infoblox/l2_drivers/ml2.py
new file mode 100644
index 0000000..51e5f36
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/l2_drivers/ml2.py
@@ -0,0 +1,27 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from neutron.ipam.drivers.infoblox import l2_driver
+
+
+class Driver(l2_driver.L2DriverBase):
+    def init_driver(self):
+        from neutron.plugins.ml2 import db
+        self.db = db
+
+    def get_network_binding(self, session, network_id):
+        # get_network_segments returns array of arrays,
+        # and we need only the first array
+        return self.db.get_network_segments(session, network_id)[0]
diff --git a/neutron/ipam/drivers/infoblox/l2_drivers/nuage.py b/neutron/ipam/drivers/infoblox/l2_drivers/nuage.py
new file mode 100644
index 0000000..14095d5
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/l2_drivers/nuage.py
@@ -0,0 +1,29 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from neutron.ipam.drivers.infoblox import l2_driver
+
+
+class Driver(l2_driver.L2DriverBase):
+    def init_driver(self):
+        pass
+
+    def get_network_binding(self, session, network_id):
+        # get_network_segments returns array of arrays,
+        # and we need only the first array
+        return {'network_type': 'none',
+                'segmentation_id': 'none',
+                'physical_network': 'none'}
+
diff --git a/neutron/ipam/drivers/infoblox/nova_manager.py b/neutron/ipam/drivers/infoblox/nova_manager.py
new file mode 100644
index 0000000..5a98e18
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/nova_manager.py
@@ -0,0 +1,47 @@
+# Copyright 2014 Infoblox.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import novaclient.v1_1.client as nclient
+from novaclient import exceptions as novaexc
+from oslo.config import cfg
+
+import logging
+
+LOG = logging.getLogger(__name__)
+
+
+class NovaManager(object):
+    _nova_client = None
+
+    def __init__(self):
+        if not NovaManager._nova_client:
+            NovaManager._nova_client = nclient.Client(
+                cfg.CONF.nova_admin_username,
+                cfg.CONF.nova_admin_password,
+                None,  # project_id - not actually used
+                auth_url=cfg.CONF.nova_admin_auth_url,
+                tenant_id=cfg.CONF.nova_admin_tenant_id,
+                service_type='compute')
+        self.nova = NovaManager._nova_client
+
+    def get_instance_name_by_id(self, instance_id):
+        try:
+            instance = self.nova.servers.get(instance_id)
+            if instance.human_id:
+                return instance.human_id
+        except (novaexc.NotFound, novaexc.BadRequest):
+            LOG.debug(_("Instance not found: %{instance_id}s"),
+                      {'instance_id': instance_id})
+        return instance_id
diff --git a/neutron/ipam/drivers/infoblox/object_manipulator.py b/neutron/ipam/drivers/infoblox/object_manipulator.py
new file mode 100755
index 0000000..77122fc
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/object_manipulator.py
@@ -0,0 +1,883 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import netaddr
+
+from neutron.ipam.drivers.infoblox import exceptions as exc
+from neutron.ipam.drivers.infoblox import objects
+from neutron.openstack.common import log as logging
+
+
+LOG = logging.getLogger(__name__)
+
+class IPBackend():
+    def __init__(self, object_manipulator):
+        self.obj_man = object_manipulator
+
+    def get_network(self, net_view_name, cidr):
+        net_data = {'network_view': net_view_name,
+                    'network': cidr}
+        net = self.obj_man._get_infoblox_object_or_none(
+            self.ib_network_name, net_data,
+            return_fields=['options', 'members'])
+        if not net:
+            raise exc.InfobloxNetworkNotAvailable(
+                net_view_name=net_view_name, cidr=cidr)
+        return objects.Network.from_dict(net)
+
+    def get_all_associated_objects(self, net_view_name, ip):
+        assoc_with_ip = {
+            'network_view': net_view_name,
+            'ip_address': ip
+        }
+        assoc_objects = self.obj_man._get_infoblox_object_or_none(
+            self.ib_ipaddr_object_name, assoc_with_ip,
+            return_fields=['objects'], proxy=True)
+        if assoc_objects:
+            return assoc_objects['objects']
+        return []
+
+    def network_exists(self, net_view_name, cidr):
+        net_data = {'network_view': net_view_name, 'network': cidr}
+        try:
+            net = self.obj_man._get_infoblox_object_or_none(
+                self.ib_network_name, net_data,
+                return_fields=['options', 'members'])
+        except exc.InfobloxSearchError:
+            net = None
+        return net is not None
+
+    def delete_network(self, net_view_name, cidr):
+        payload = {'network_view': net_view_name,
+                   'network': cidr}
+        self.obj_man._delete_infoblox_object(
+            self.ib_network_name, payload)
+
+    def delete_ip_range(self, net_view, start_ip, end_ip):
+        range_data = {'start_addr': start_ip,
+                      'end_addr': end_ip,
+                      'network_view': net_view}
+        self.obj_man._delete_infoblox_object(self.ib_range_name, range_data)
+
+    def delete_ip_from_host_record(self, host_record, ip):
+        host_record.ips.remove(ip)
+        self.obj_man._update_host_record_ips(self.ib_ipaddrs_name, host_record)
+        return host_record
+
+    def delete_host_record(self, dns_view_name, ip_address):
+        host_record_data = {'view': dns_view_name,
+                            self.ib_ipaddr_name: ip_address}
+        self.obj_man._delete_infoblox_object(
+            'record:host', host_record_data)
+
+    def delete_fixed_address(self, network_view, ip):
+        fa_data = {'network_view': network_view,
+                   self.ib_ipaddr_name: ip}
+        self.obj_man._delete_infoblox_object(
+            self.ib_fixedaddress_name, fa_data)
+
+    def bind_name_with_host_record(self, dnsview_name, ip, name, extattrs):
+        record_host = {
+            self.ib_ipaddr_name: ip,
+            'view': dnsview_name
+        }
+        update_kwargs = {'name': name, 'extattrs': extattrs}
+        self.obj_man._update_infoblox_object(
+            'record:host', record_host, update_kwargs)
+
+    def update_host_record_eas(self, dns_view, ip, extattrs):
+        fa_data = {'view': dns_view,
+                   self.ib_ipaddr_name: ip}
+        fa = self.obj_man._get_infoblox_object_or_none(
+            'record:host', fa_data)
+        if fa:
+            self.obj_man._update_infoblox_object_by_ref(
+                fa, {'extattrs': extattrs})
+
+    def update_fixed_address_eas(self, network_view, ip, extattrs):
+        fa_data = {'network_view': network_view,
+                   self.ib_ipaddr_name: ip}
+        fa = self.obj_man._get_infoblox_object_or_none(
+            self.ib_fixedaddress_name, fa_data)
+        if fa:
+            self.obj_man._update_infoblox_object_by_ref(
+                fa, {'extattrs': extattrs})
+
+    def update_dns_record_eas(self, dns_view, ip, extattrs):
+        fa_data = {'view': dns_view,
+                   self.ib_ipaddr_name: ip}
+        fa = self.obj_man._get_infoblox_object_or_none(
+            'record:a', fa_data)
+        if fa:
+            self.obj_man._update_infoblox_object_by_ref(
+                fa, {'extattrs': extattrs})
+
+        fa = self.obj_man._get_infoblox_object_or_none(
+            'record:ptr', fa_data)
+        if fa:
+            self.obj_man._update_infoblox_object_by_ref(
+                fa, {'extattrs': extattrs})
+
+
+class IPv4Backend(IPBackend):
+    ib_ipaddr_name = 'ipv4addr'
+    ib_ipaddrs_name = 'ipv4addrs'
+    ib_ipaddr_object_name = 'ipv4address'
+    ib_network_name = 'network'
+    ib_fixedaddress_name = 'fixedaddress'
+    ib_range_name = 'range'
+
+    def create_network(self, net_view_name, cidr, nameservers=None,
+                       members=None, gateway_ip=None, dhcp_trel_ip=None,
+                       network_extattrs=None):
+        network_data = {'network_view': net_view_name,
+                        'network': cidr,
+                        'extattrs': network_extattrs}
+        members_struct = []
+        for member in members:
+            members_struct.append({'ipv4addr': member.ip,
+                                   '_struct': 'dhcpmember'})
+        network_data['members'] = members_struct
+
+        dhcp_options = []
+
+        if nameservers:
+            dhcp_options.append({'name': 'domain-name-servers',
+                                 'value': ",".join(nameservers)})
+
+        if gateway_ip:
+            dhcp_options.append({'name': 'routers',
+                                 'value': gateway_ip})
+
+        if dhcp_trel_ip:
+            dhcp_options.append({'name': 'dhcp-server-identifier',
+                                 'num': 54,
+                                 'value': dhcp_trel_ip})
+
+        if dhcp_options:
+            network_data['options'] = dhcp_options
+
+        return self.obj_man._create_infoblox_object(
+            self.ib_network_name, network_data, check_if_exists=False)
+
+    def create_ip_range(self, network_view, start_ip, end_ip, network,
+                        disable, range_extattrs):
+        range_data = {'start_addr': start_ip,
+                      'end_addr': end_ip,
+                      'extattrs': range_extattrs,
+                      'network_view': network_view}
+        ib_object = self.obj_man._get_infoblox_object_or_none('range',
+                                                              range_data)
+        if not ib_object:
+            range_data['disable'] = disable
+            self.obj_man._create_infoblox_object(
+                'range', range_data, check_if_exists=False)
+
+    def add_ip_to_record(self, host_record, ip, mac):
+        host_record.ips.append(objects.IPv4(ip, mac))
+        ips = self.obj_man._update_host_record_ips('ipv4addrs', host_record)
+        hr = objects.HostRecordIPv4.from_dict(ips)
+        return hr
+
+    def create_host_record(self):
+        return objects.HostRecordIPv4()
+
+    def get_host_record(self, dns_view, ip):
+        data = {
+            'view': dns_view,
+            'ipv4addr': ip
+        }
+
+        raw_host_record = self.obj_man._get_infoblox_object_or_none(
+            'record:host', data, return_fields=['ipv4addrs'])
+
+        if raw_host_record:
+            hr = objects.HostRecordIPv4.from_dict(raw_host_record)
+            return hr
+
+    def get_fixed_address(self):
+        return objects.FixedAddressIPv4()
+
+    def bind_name_with_record_a(self, dnsview_name, ip, name, bind_list,
+                                extattrs):
+        # Forward mapping
+        if 'record:a' in bind_list:
+            payload = {
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            additional_create_kwargs = {
+                'name': name,
+                'extattrs':extattrs
+            }
+            self.obj_man._create_infoblox_object(
+                'record:a', payload,
+                additional_create_kwargs,
+                update_if_exists=True)
+
+        # Reverse mapping
+        if 'record:ptr' in bind_list:
+            record_ptr_data = {
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            additional_create_kwargs = {
+                'ptrdname': name,
+                'extattrs': extattrs
+            }
+            self.obj_man._create_infoblox_object(
+                'record:ptr', record_ptr_data,
+                additional_create_kwargs,
+                update_if_exists=True)
+
+    def unbind_name_from_record_a(self, dnsview_name, ip, name, unbind_list):
+        if 'record:a' in unbind_list:
+            dns_record_a = {
+                'name': name,
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            self.obj_man._delete_infoblox_object(
+                'record:a', dns_record_a)
+
+        if 'record:ptr' in unbind_list:
+            dns_record_ptr = {
+                'ptrdname': name,
+                'view': dnsview_name
+            }
+            self.obj_man._delete_infoblox_object(
+                'record:ptr', dns_record_ptr)
+
+    def find_hostname(self, dns_view, hostname):
+        data = {
+            'name': hostname,
+            'view': dns_view
+        }
+
+        raw_host_record = self.obj_man._get_infoblox_object_or_none(
+            'record:host', data, return_fields=['ipv4addrs'])
+
+        if raw_host_record:
+            hr = objects.HostRecordIPv4.from_dict(raw_host_record)
+            return hr
+
+
+class IPv6Backend(IPBackend):
+    ib_ipaddr_name = 'ipv6addr'
+    ib_ipaddrs_name = 'ipv6addrs'
+    ib_ipaddr_object_name = 'ipv6address'
+    ib_network_name = 'ipv6network'
+    ib_fixedaddress_name = 'ipv6fixedaddress'
+    ib_range_name = 'ipv6range'
+
+    def create_network(self, net_view_name, cidr, nameservers=None,
+                       members=None, gateway_ip=None, dhcp_trel_ip=None,
+                       network_extattrs=None):
+        network_data = {'network_view': net_view_name,
+                        'network': cidr,
+                        'extattrs': network_extattrs}
+
+        # member here takes ipv4addr since pre-hellfire NIOS version does not
+        # support ipv6addr (Hellfire supports ipv6addr.
+        # We are using ipv4addr to suppport both versions
+        # This is just to the GM know which member is used for
+        # their internal communication between GM and member so
+        # it has nothing to do wiht DHCP protocol.
+        members_struct = []
+        for member in members:
+            members_struct.append(member.specifier)
+        network_data['members'] = members_struct
+
+        dhcp_options = []
+
+        if nameservers:
+            dhcp_options.append({'name': 'domain-name-servers',
+                                 'value': ",".join(nameservers)})
+
+        if dhcp_options:
+            network_data['options'] = dhcp_options
+
+        return self.obj_man._create_infoblox_object(
+            self.ib_network_name, network_data, check_if_exists=False)
+
+    def create_ip_range(self, network_view, start_ip, end_ip, network,
+                        disable, range_extattrs):
+        range_data = {'start_addr': start_ip,
+                      'end_addr': end_ip,
+                      'extattrs': range_extattrs,
+                      'network': network,
+                      'network_view': network_view}
+        ib_object = self.obj_man._get_infoblox_object_or_none('ipv6range',
+                                                              range_data)
+        if not ib_object:
+            range_data['disable'] = disable
+            self.obj_man._create_infoblox_object(
+                'ipv6range', range_data, check_if_exists=False)
+
+    def add_ip_to_record(self, host_record, ip, mac):
+        host_record.ips.append(objects.IPv6(ip, mac))
+        ips = self.obj_man._update_host_record_ips('ipv6addrs', host_record)
+        hr = objects.HostRecordIPv6.from_dict(ips)
+        return hr
+
+    def create_host_record(self):
+        return objects.HostRecordIPv6()
+
+    def get_host_record(self, dns_view, ip):
+        data = {
+            'view': dns_view,
+            'ipv6addr': ip
+        }
+
+        raw_host_record = self.obj_man._get_infoblox_object_or_none(
+            'record:host', data, return_fields=['ipv6addrs'])
+
+        if raw_host_record:
+            hr = objects.HostRecordIPv6.from_dict(raw_host_record)
+            return hr
+
+    def get_fixed_address(self):
+        return objects.FixedAddressIPv6()
+
+    def bind_name_with_record_a(self, dnsview_name, ip, name, bind_list,
+                                extattrs):
+        # Forward mapping
+        if 'record:aaaa' in bind_list:
+            payload = {
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            additional_create_kwargs = {
+                'name': name,
+                'extattrs':extattrs
+            }
+            self.obj_man._create_infoblox_object(
+                'record:aaaa', payload,
+                additional_create_kwargs,
+                update_if_exists=True)
+
+        # Reverse mapping
+        if 'record:ptr' in bind_list:
+            record_ptr_data = {
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            additional_create_kwargs = {
+                'ptrdname': name,
+                'extattrs': extattrs
+            }
+            self.obj_man._create_infoblox_object(
+                'record:ptr', record_ptr_data,
+                additional_create_kwargs,
+                update_if_exists=True)
+
+    def unbind_name_from_record_a(self, dnsview_name, ip, name, unbind_list):
+        if 'record:aaaa' in unbind_list:
+            dns_record_a = {
+                'name': name,
+                self.ib_ipaddr_name: ip,
+                'view': dnsview_name
+            }
+            self.obj_man._delete_infoblox_object(
+                'record:aaaa', dns_record_a)
+
+        if 'record:ptr' in unbind_list:
+            dns_record_ptr = {
+                'ptrdname': name,
+                'view': dnsview_name
+            }
+            self.obj_man._delete_infoblox_object(
+                'record:ptr', dns_record_ptr)
+
+    def find_hostname(self, dns_view, hostname):
+        data = {
+            'name': hostname,
+            'view': dns_view
+        }
+
+        raw_host_record = self.obj_man._get_infoblox_object_or_none(
+            'record:host', data, return_fields=['ipv6addrs'])
+
+        if raw_host_record:
+            hr = objects.HostRecordIPv6.from_dict(raw_host_record)
+            return hr
+
+
+class IPBackendFactory():
+    @staticmethod
+    def get_ip_version(ipaddr):
+        if type(ipaddr) is dict:
+            ip = ipaddr['ip_address']
+        else:
+            ip = ipaddr
+
+        try:
+            ip = netaddr.IPAddress(ip)
+        except ValueError:
+            ip = netaddr.IPNetwork(ip)
+        return ip.version
+
+    @staticmethod
+    def get(obj_man, ip):
+        ip = IPBackendFactory.get_ip_version(ip)
+        if ip == 4:
+            return IPv4Backend(obj_man)
+        elif ip == 6:
+            return IPv6Backend(obj_man)
+
+
+class InfobloxObjectManipulator(object):
+    def __init__(self, connector):
+        self.connector = connector
+
+    def create_network_view(self, netview_name, nview_extattrs, member):
+        net_view_data = {'name': netview_name,
+                         'extattrs': nview_extattrs}
+        return self._create_infoblox_object('networkview', net_view_data,
+                                    delegate_member=member)
+
+    def delete_network_view(self, net_view_name):
+        # never delete default network view
+        if net_view_name == 'default':
+            return
+
+        net_view_data = {'name': net_view_name}
+        self._delete_infoblox_object('networkview', net_view_data)
+
+    def create_dns_view(self, net_view_name, dns_view_name):
+        dns_view_data = {'name': dns_view_name,
+                         'network_view': net_view_name}
+        return self._create_infoblox_object('view', dns_view_data)
+
+    def delete_dns_view(self, net_view_name):
+        net_view_data = {'name': net_view_name}
+        self._delete_infoblox_object('view', net_view_data)
+
+    def get_network(self, net_view_name, cidr):
+        ip_backend = IPBackendFactory.get(self, cidr)
+        return ip_backend.get_network(net_view_name, cidr)
+
+    def has_networks(self, network_view_name):
+        net_data = {'network_view': network_view_name}
+        try:
+            ib_net = self._get_infoblox_object_or_none('network', net_data)
+            return bool(ib_net)
+        except exc.InfobloxSearchError:
+            return False
+
+    def network_exists(self, net_view_name, cidr):
+        ip_backend = IPBackendFactory.get(self, cidr)
+        return ip_backend.network_exists(net_view_name, cidr)
+
+    def create_network(self, net_view_name, cidr, nameservers=None,
+                       members=None, gateway_ip=None, dhcp_trel_ip=None,
+                       network_extattrs=None):
+        ip_backend = IPBackendFactory.get(self, cidr)
+        ip_backend.create_network(net_view_name, cidr, nameservers,
+                                  members, gateway_ip, dhcp_trel_ip,
+                                  network_extattrs)
+
+    def delete_network(self, net_view_name, cidr):
+        ip_backend = IPBackendFactory.get(self, cidr)
+        ip_backend.delete_network(net_view_name, cidr)
+
+    def create_network_from_template(self, net_view_name, cidr, template,
+                                     network_extattrs):
+        network_data = {
+            'network_view': net_view_name,
+            'network': cidr,
+            'template': template,
+            'extattrs': network_extattrs
+        }
+        return self._create_infoblox_object('network', network_data,
+                                            check_if_exists=False)
+
+    def update_network_options(self, ib_network, extattrs=None):
+        payload = {}
+        if ib_network.options:
+            payload['options'] = ib_network.options
+        if extattrs:
+            payload['extattrs'] = extattrs
+        self._update_infoblox_object_by_ref(ib_network.ref, payload)
+
+    def create_ip_range(self, network_view, start_ip, end_ip, network,
+                        disable, range_extattrs):
+        ip_backend = IPBackendFactory.get(self, start_ip)
+        ip_backend.create_ip_range(network_view, start_ip, end_ip,
+                                   network, disable, range_extattrs)
+
+    def delete_ip_range(self, net_view, start_ip, end_ip):
+        ip_backend = IPBackendFactory.get(self, start_ip)
+        ip_backend.delete_ip_range(net_view, start_ip, end_ip)
+
+    def get_host_record(self, dns_view, ip):
+        ip_backend = IPBackendFactory.get(self, ip)
+        return ip_backend.get_host_record(dns_view, ip)
+
+    def find_hostname(self, dns_view, hostname, ip):
+        ip_backend = IPBackendFactory.get(self, ip)
+        return ip_backend.find_hostname(dns_view, hostname)
+
+    def create_host_record_for_given_ip(self, dns_view_name, zone_auth,
+                                        hostname, mac, ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+
+        hr = ip_backend.create_host_record()
+        hr.ip_version = IPBackendFactory.get_ip_version(ip)
+        hr.hostname = hostname
+        hr.zone_auth = zone_auth
+        hr.mac = mac
+        hr.dns_view = dns_view_name
+        hr.ip = ip
+        hr.extattrs = extattrs
+
+        created_hr = self._create_infoblox_ip_address(hr)
+        return created_hr
+
+    def create_host_record_from_range(self, dns_view_name, network_view_name,
+                                      zone_auth, hostname, mac, first_ip,
+                                      last_ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, first_ip)
+
+        hr = ip_backend.create_host_record()
+        hr.ip_version = IPBackendFactory.get_ip_version(first_ip)
+        hr.hostname = hostname
+        hr.zone_auth = zone_auth
+        hr.mac = mac
+        hr.dns_view = dns_view_name
+        hr.ip = objects.IPAllocationObject.next_available_ip_from_range(
+            network_view_name, first_ip, last_ip)
+        hr.extattrs = extattrs
+
+        created_hr = self._create_infoblox_ip_address(hr)
+        return created_hr
+
+    def delete_host_record(self, dns_view_name, ip_address):
+        ip_backend = IPBackendFactory.get(self, ip_address)
+        ip_backend.delete_host_record(dns_view_name, ip_address)
+
+    def create_fixed_address_for_given_ip(self, network_view, mac, ip,
+                                          extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+
+        fa = ip_backend.get_fixed_address()
+        fa.ip = ip
+        fa.net_view = network_view
+        fa.mac = mac
+        fa.extattrs = extattrs
+
+        created_fa = self._create_infoblox_ip_address(fa)
+        return created_fa
+
+    def create_fixed_address_from_range(self, network_view, mac, first_ip,
+                                        last_ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, first_ip)
+
+        fa = ip_backend.get_fixed_address()
+        fa.ip = objects.IPAllocationObject.next_available_ip_from_range(
+            network_view, first_ip, last_ip)
+        fa.net_view = network_view
+        fa.mac = mac
+        fa.extattrs = extattrs
+
+        created_fa = self._create_infoblox_ip_address(fa)
+        return created_fa
+
+    def create_fixed_address_from_cidr(self, network_view, mac, cidr,
+                                       extattrs):
+        ip_backend = IPBackendFactory.get(self, cidr)
+
+        fa = ip_backend.get_fixed_address()
+        fa.ip = objects.IPAllocationObject.next_available_ip_from_cidr(
+            network_view, cidr)
+        fa.mac = mac
+        fa.net_view = network_view
+        fa.extattrs = extattrs
+
+        created_fa = self._create_infoblox_ip_address(fa)
+        return created_fa
+
+    def delete_fixed_address(self, network_view, ip_address):
+        ip_backend = IPBackendFactory.get(self, ip_address)
+        ip_backend.delete_fixed_address(network_view, ip_address)
+
+    def add_ip_to_record(self, host_record, ip, mac):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.add_ip_to_record(host_record, ip, mac)
+
+    def add_ip_to_host_record_from_range(self, host_record, network_view,
+                                         mac, first_ip, last_ip):
+        ip = objects.IPAllocationObject.next_available_ip_from_range(
+            network_view, first_ip, last_ip)
+        hr = self.add_ip_to_record(host_record, ip, mac)
+        return hr
+
+    def delete_ip_from_host_record(self, host_record, ip):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.delete_ip_from_host_record(host_record, ip)
+
+    def has_dns_zones(self, dns_view):
+        zone_data = {'view': dns_view}
+        try:
+            zone = self._get_infoblox_object_or_none('zone_auth', zone_data)
+            return bool(zone)
+        except exc.InfobloxSearchError:
+            return False
+
+    def create_dns_zone(self, dns_view, dns_zone_fqdn, primary_dns_member=None,
+                        secondary_dns_members=None, zone_format=None,
+                        ns_group=None, prefix=None, zone_extattrs={}):
+        # TODO(mirantis) support IPv6
+        dns_zone_data = {'fqdn': dns_zone_fqdn,
+                         'view': dns_view,
+                         'extattrs': zone_extattrs}
+        additional_create_kwargs = {}
+
+        if primary_dns_member:
+            grid_primary = [{'name': primary_dns_member.name,
+                             '_struct': 'memberserver'}]
+            additional_create_kwargs['grid_primary'] = grid_primary
+
+        if secondary_dns_members:
+            grid_secondaries = [{'name': member.name,
+                                 '_struct': 'memberserver'}
+                                for member in secondary_dns_members]
+            additional_create_kwargs['grid_secondaries'] = grid_secondaries
+
+        if zone_format:
+            additional_create_kwargs['zone_format'] = zone_format
+
+        if ns_group:
+            additional_create_kwargs['ns_group'] = ns_group
+
+        if prefix:
+            additional_create_kwargs['prefix'] = prefix
+
+        try:
+            self._create_infoblox_object(
+                'zone_auth', dns_zone_data, additional_create_kwargs,
+                check_if_exists=True)
+        except exc.InfobloxCannotCreateObject:
+            LOG.warning(
+                _('Unable to create DNS zone %(dns_zone_fqdn)s '
+                  'for %(dns_view)s'),
+                {'dns_zone_fqdn': dns_zone_fqdn, 'dns_view': dns_view})
+
+    def delete_dns_zone(self, dns_view, dns_zone_fqdn):
+        dns_zone_data = {'fqdn': dns_zone_fqdn,
+                         'view': dns_view}
+        self._delete_infoblox_object('zone_auth', dns_zone_data)
+
+    def update_host_record_eas(self, dns_view, ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.update_host_record_eas(dns_view, ip, extattrs)
+
+    def update_fixed_address_eas(self, network_view, ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.update_fixed_address_eas(network_view, ip, extattrs)
+
+    def update_dns_record_eas(self, dns_view, ip, extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.update_dns_record_eas(dns_view, ip, extattrs)
+
+    def bind_name_with_host_record(self, dnsview_name, ip, name, extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.bind_name_with_host_record(dnsview_name, ip, name, extattrs)
+
+    def bind_name_with_record_a(self, dnsview_name, ip, name, bind_list,
+                                extattrs):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.bind_name_with_record_a(dnsview_name, ip, name, bind_list,
+                                           extattrs)
+
+    def unbind_name_from_record_a(self, dnsview_name, ip, name, unbind_list):
+        ip_backend = IPBackendFactory.get(self, ip)
+        ip_backend.unbind_name_from_record_a(
+            dnsview_name, ip, name, unbind_list)
+
+    def get_member(self, member):
+        return self.connector.get_object('member', {'host_name': member.name})
+
+    def restart_all_services(self, member):
+        ib_member = self.get_member(member)[0]
+        self.connector.call_func('restartservices', ib_member['_ref'],
+                                 {'restart_option': 'RESTART_IF_NEEDED',
+                                  'service_option': 'ALL'})
+
+    def get_object_refs_associated_with_a_record(self, a_record_ref):
+        associated_with_a_record = [  # {object_type, search_field}
+            {'type': 'record:cname', 'search': 'canonical'},
+            {'type': 'record:txt', 'search': 'name'}
+        ]
+
+        obj_refs = []
+        a_record = self.connector.get_object(a_record_ref)
+
+        for rec_inf in associated_with_a_record:
+            objs = self.connector.get_object(
+                rec_inf['type'], {'view': a_record['view'],
+                                  rec_inf['search']: a_record['name']})
+            if objs:
+                for obj in objs:
+                    obj_refs.append(obj['_ref'])
+
+        return obj_refs
+
+    def get_all_associated_objects(self, net_view_name, ip):
+        ip_backend = IPBackendFactory.get(self, ip)
+        return ip_backend.get_all_associated_objects(net_view_name, ip)
+
+    def delete_all_associated_objects(self, net_view_name, ip, delete_list):
+        del_objs = []
+        obj_refs = self.get_all_associated_objects(net_view_name, ip)
+
+        for obj_ref in obj_refs:
+            del_objs.append(obj_ref)
+            if self._get_object_type_from_ref(obj_ref) \
+                                    in ['record:a', 'record:aaaa']:
+                del_objs.extend(
+                    self.get_object_refs_associated_with_a_record(obj_ref))
+
+        for obj_ref in del_objs:
+            if self._get_object_type_from_ref(obj_ref) in delete_list:
+                self.connector.delete_object(obj_ref)
+
+    def delete_object_by_ref(self, ref):
+        try:
+            self.connector.delete_object(ref)
+        except exc.InfobloxCannotDeleteObject as e:
+            LOG.info(_("Failed to delete an object: %s"), e)
+
+    def _create_infoblox_ip_address(self, ip_object):
+        try:
+            created_ip_json = self._create_infoblox_object(
+                ip_object.infoblox_type,
+                ip_object.to_dict(),
+                check_if_exists=False,
+                return_fields=ip_object.return_fields)
+
+            return ip_object.from_dict(created_ip_json)
+        except exc.InfobloxCannotCreateObject as e:
+            if "Cannot find 1 available IP" in e.response['text']:
+                raise exc.InfobloxCannotAllocateIp(ip_data=ip_object.to_dict())
+            else:
+                raise e
+        except exc.HostRecordNotPresent:
+            raise exc.InfobloxHostRecordIpAddrNotCreated(ip=ip_object.ip,
+                                                         mac=ip_object.mac)
+        except exc.InfobloxInvalidIp:
+            raise exc.InfobloxDidNotReturnCreatedIPBack()
+
+    def _create_infoblox_object(self, obj_type, payload,
+                                additional_create_kwargs=None,
+                                check_if_exists=True,
+                                return_fields=None,
+                                delegate_member=None,
+                                update_if_exists=False):
+        if additional_create_kwargs is None:
+            additional_create_kwargs = {}
+
+        ib_object = None
+        if check_if_exists or update_if_exists:
+            ib_object = self._get_infoblox_object_or_none(obj_type, payload)
+            if ib_object:
+                LOG.info(
+                    _("Infoblox %(obj_type)s "
+                      "already exists: %(ib_object)s"),
+                    {'obj_type': obj_type, 'ib_object': ib_object})
+
+        if not ib_object:
+            payload.update(additional_create_kwargs)
+            ib_object = self.connector.create_object(obj_type, payload,
+                                            return_fields, delegate_member)
+            LOG.info(
+                _("Infoblox %(obj_type)s "
+                  "was created: %(ib_object)s"),
+                {'obj_type': obj_type, 'ib_object': ib_object})
+        elif update_if_exists:
+            self._update_infoblox_object_by_ref(ib_object,
+                                                additional_create_kwargs)
+
+        return ib_object
+
+    def _get_infoblox_object_or_none(self, obj_type, payload,
+                                     return_fields=None, proxy=False):
+        # Ignore 'extattrs' for get_object, since this field is not searchible
+        search_payload = {}
+        for key in payload:
+            if key is not 'extattrs':
+                search_payload[key] = payload[key]
+        ib_object = self.connector.get_object(obj_type, search_payload,
+                                              return_fields, proxy=proxy)
+        if ib_object:
+            if return_fields:
+                return ib_object[0]
+            else:
+                return ib_object[0]['_ref']
+
+        return None
+
+    def _update_infoblox_object(self, obj_type, payload, update_kwargs):
+        ib_object_ref = None
+        warn_msg = _('Infoblox %(obj_type)s will not be updated because'
+                     ' it cannot be found: %(payload)s')
+        try:
+            ib_object_ref = self._get_infoblox_object_or_none(obj_type,
+                                                              payload)
+            if not ib_object_ref:
+                LOG.warning(warn_msg, {'obj_type': obj_type,
+                                       'payload': payload})
+        except exc.InfobloxSearchError as e:
+            LOG.warning(warn_msg, obj_type, payload)
+            LOG.info(e)
+
+        if ib_object_ref:
+            self._update_infoblox_object_by_ref(ib_object_ref, update_kwargs)
+
+    def _update_infoblox_object_by_ref(self, ref, update_kwargs,
+                                       return_fields=None):
+        updated_object = self.connector.update_object(ref, update_kwargs,
+                                                      return_fields)
+        LOG.info(_('Infoblox object was updated: %s'), ref)
+        return updated_object
+
+    def _delete_infoblox_object(self, obj_type, payload):
+        ib_object_ref = None
+        warn_msg = _('Infoblox %(obj_type)s will not be deleted because'
+                     ' it cannot be found: %(payload)s')
+        try:
+            ib_object_ref = self._get_infoblox_object_or_none(obj_type,
+                                                              payload)
+            if not ib_object_ref:
+                LOG.warning(warn_msg, {'obj_type': obj_type,
+                                       'payload': payload})
+        except exc.InfobloxSearchError as e:
+            LOG.warning(warn_msg, {'obj_type': obj_type,
+                                   'payload': payload})
+            LOG.info(e)
+
+        if ib_object_ref:
+            self.connector.delete_object(ib_object_ref)
+            LOG.info(_('Infoblox object was deleted: %s'), ib_object_ref)
+
+    def _update_host_record_ips(self, ipaddrs_name, host_record):
+        ipaddrs = {ipaddrs_name: [ip.to_dict(add_host=False)
+                                  for ip in host_record.ips]}
+        return self._update_infoblox_object_by_ref(
+            host_record.ref, ipaddrs, return_fields=[ipaddrs_name])
+
+    @staticmethod
+    def _get_object_type_from_ref(ref):
+        return ref.split('/', 1)[0]
diff --git a/neutron/ipam/drivers/infoblox/objects.py b/neutron/ipam/drivers/infoblox/objects.py
new file mode 100755
index 0000000..24cdd48
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/objects.py
@@ -0,0 +1,663 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import logging
+import netaddr
+import six
+import random
+from oslo.config import cfg
+import neutron.ipam.drivers.infoblox.exceptions as ib_exc
+
+
+OPTS = [
+    cfg.BoolOpt('use_dhcp_for_ip_allocation_record',
+                default=True,
+                help=_("Used to set 'configure_for_dhcp' option to enable "
+                       " or disable dhcp for host or fixed record"))
+]
+
+cfg.CONF.register_opts(OPTS)
+LOG = logging.getLogger(__name__)
+
+
+def is_valid_ip(ip):
+    try:
+        netaddr.IPAddress(ip)
+    except netaddr.core.AddrFormatError:
+        return False
+    return True
+
+
+def generate_duid(mac):
+    duid = [0x00,
+            random.randint(0x00, 0x7f),
+            random.randint(0x00, 0xff),
+            random.randint(0x00, 0xff)]
+    return ':'.join(map(lambda x: "%02x" % x, duid)) + ':' + mac
+
+
+class Network(object):
+    """Sample Infoblox 'network' object in JSON format:
+    [
+        {
+            "_ref": "network/ZG5zLm5ldHdvcmskMTAuMzkuMTEuMC8yNC8w:
+                     10.39.11.0/24/default",
+            "members": [
+                {
+                    "_struct": "dhcpmember",
+                    "ipv4addr": "10.39.11.123",
+                    "name": "infoblox.localdomain"
+                }
+            ],
+            "options": [
+                {
+                    "name": "dhcp-lease-time",
+                    "num": 51,
+                    "use_option": false,
+                    "value": "43200",
+                    "vendor_class": "DHCP"
+                },
+                {
+                    "name": "domain-name-servers",
+                    "num": 6,
+                    "use_option": true,
+                    "value": "10.39.11.123",
+                    "vendor_class": "DHCP"
+                },
+                {
+                    "name": "routers",
+                    "num": 3,
+                    "use_option": false,
+                    "value": "10.39.11.1",
+                    "vendor_class": "DHCP"
+                }
+            ]
+        }
+    ]
+    """
+    DNS_NAMESERVERS_OPTION = 'domain-name-servers'
+
+    def __init__(self):
+        self.infoblox_type = 'network'
+        self.members = []
+        self.options = []
+        self.member_ip_addrs = []
+        self.infoblox_reference = None
+        self.ref = None
+
+    def __repr__(self):
+        return "{0}".format(self.to_dict())
+
+    @staticmethod
+    def from_dict(network_ib_object):
+        net = Network()
+        net.members = network_ib_object['members']
+        net.options = network_ib_object['options']
+
+        for member in net.members:
+            net.member_ip_addrs.append(member['ipv4addr'])
+        net.ref = network_ib_object['_ref']
+        return net
+
+    @property
+    def dns_nameservers(self):
+        # NOTE(max_lobur): The behaviour of the WAPI is as follows:
+        # * If the subnet created without domain-name-servers option it will
+        # be absent in the options list.
+        # * If the subnet created with domain-name-servers option and then
+        # it's cleared by update operation, the option will be present in
+        # the list, will carry the last data, but will have use_option = False
+        # Both cases mean that there are NO specified nameservers on NIOS.
+        dns_nameservers = []
+        for opt in self.options:
+            if self._is_dns_option(opt):
+                if opt.get('use_option', True):
+                    dns_nameservers = opt['value'].split(',')
+                    break
+        return dns_nameservers
+
+    @dns_nameservers.setter
+    def dns_nameservers(self, value):
+        for opt in self.options:
+            if self._is_dns_option(opt):
+                if value:
+                    opt['value'] = ",".join(value)
+                    opt['use_option'] = True
+                else:
+                    opt['use_option'] = False
+                break
+        else:
+            if value:
+                self.options.append(dict(
+                    name=self.DNS_NAMESERVERS_OPTION,
+                    value=",".join(value),
+                    use_option=True
+                ))
+
+    def has_dns_members(self):
+        for opt in self.options:
+            if self._is_dns_option(opt):
+                return True
+        return False
+
+    def _is_member_ip(self, ip):
+        return ip in self.member_ip_addrs
+
+    def update_member_ip_in_dns_nameservers(self, relay_ip):
+        for opt in self.options:
+            if self._is_dns_option(opt):
+                original_value = opt['value'].split(',')
+                original_value.insert(0, relay_ip)
+                opt['value'] = ",".join(
+                    [val for val in original_value
+                        if val and not self._is_member_ip(val)])
+
+                return
+
+    def to_dict(self):
+        return {
+            'members': self.members,
+            'options': self.options
+        }
+
+    @staticmethod
+    def _is_dns_option(option):
+        return option['name'] == Network.DNS_NAMESERVERS_OPTION
+
+
+class IPAddress(object):
+    def __init__(self, ip=None, mac=None):
+        self.ip = ip
+        self.mac = mac
+        self.configure_for_dhcp = cfg.CONF.use_dhcp_for_ip_allocation_record
+        self.hostname = None
+        self.dns_zone = None
+        self.fqdn = None
+
+    def __eq__(self, other):
+        if isinstance(other, six.string_types):
+            return self.ip == other
+        elif isinstance(other, self.__class__):
+            return self.ip == other.ip and self.dns_zone == other.dns_zone
+        return False
+
+
+class IPv4(IPAddress):
+    def to_dict(self, add_host=False):
+        d = {
+            "ipv4addr": self.ip,
+            "configure_for_dhcp": self.configure_for_dhcp
+        }
+
+        if self.fqdn and add_host:
+            d['host'] = self.fqdn
+
+        if self.mac:
+            d['mac'] = self.mac
+
+        return d
+
+    def __repr__(self):
+        return "IPv4Addr{0}".format(self.to_dict())
+
+    @staticmethod
+    def from_dict(d):
+        ip = d.get('ipv4addr')
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+
+        ipv4obj = IPv4()
+        host = d.get('host', 'unknown.unknown')
+        hostname, _, dns_zone = host.partition('.')
+        ipv4obj.ip = ip
+        ipv4obj.mac = d.get('mac')
+        ipv4obj.configure_for_dhcp = d.get('configure_for_dhcp')
+        ipv4obj.hostname = hostname
+        ipv4obj.zone_auth = dns_zone
+        ipv4obj.fqdn = host
+        return ipv4obj
+
+
+class IPv6(IPAddress):
+    def to_dict(self, add_host=False):
+        d = {
+            "ipv6addr": self.ip,
+            "configure_for_dhcp": self.configure_for_dhcp
+        }
+
+        if self.fqdn and add_host:
+            d['host'] = self.fqdn
+
+        if self.mac:
+            d['duid'] = generate_duid(self.mac)
+
+        return d
+
+    def __repr__(self):
+        return "IPv6Addr{0}".format(self.to_dict())
+
+    @staticmethod
+    def from_dict(d):
+        ip = d.get('ipv6addr')
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+
+        ipv6obj = IPv6()
+        host = d.get('host', 'unknown.unknown')
+        hostname, _, dns_zone = host.partition('.')
+        ipv6obj.ip = ip
+        ipv6obj.duid = d.get('duid')
+        ipv6obj.configure_for_dhcp = d.get('configure_for_dhcp')
+        ipv6obj.hostname = hostname
+        ipv6obj.zone_auth = dns_zone
+        ipv6obj.fqdn = host
+        return ipv6obj
+
+
+class IPAllocationObject(object):
+    @staticmethod
+    def next_available_ip_from_cidr(net_view_name, cidr):
+        return ('func:nextavailableip:'
+                '{cidr:s},{net_view_name:s}').format(**locals())
+
+    @staticmethod
+    def next_available_ip_from_range(net_view_name, first_ip, last_ip):
+        return ('func:nextavailableip:'
+                '{first_ip}-{last_ip},{net_view_name}').format(**locals())
+
+
+class HostRecord(IPAllocationObject):
+    def __init__(self):
+        self.infoblox_type = 'record:host'
+        self.ips = []
+        self.ref = None
+        self.name = None
+        self.dns_view = None
+        self.extattrs = None
+        self.configure_for_dhcp = cfg.CONF.use_dhcp_for_ip_allocation_record
+
+    def __repr__(self):
+        return "HostRecord{0}".format(self.to_dict())
+
+    def __eq__(self, other):
+        return (isinstance(other, self.__class__) and
+                self.ips == other.ips and
+                self.name == other.name and
+                self.dns_view == other.dns_view)
+
+    @property
+    def zone_auth(self):
+        return self._zone_auth
+
+    @zone_auth.setter
+    def zone_auth(self, value):
+        if value:
+            self._zone_auth = value.lstrip('.')
+
+
+class HostRecordIPv4(HostRecord):
+    """Sample Infoblox host record object in JSON format:
+    {
+        u'_ref': u'record:host/ZG5zLmhvc3QkLl9kZWZhdWx0LmNvbS5nbG9iYWwuY22NA
+                   :test_host_name.testsubnet.cloud.global.com/default',
+        u'ipv4addrs': [
+            {
+                u'configure_for_dhcp': False,
+                u'_ref': u'record:host_ipv4addr/lMmQ3ZjkuMmM4ZjhlOTctMGQ5Mi00Y2:22.0.0.2/
+                         test_host_name.testsubnet.cloud.global.com/default', u'ipv4addr': u'22.0.0.2',
+                u'mac': u'fa:16:3e:29:87:70',
+                u'host': u'2c8f8e97-0d92-4cac-a350-09a0c53fe664.33c00d42-9715-43fe-862c-6ff2b7e2d7f9.cloud.global.com'
+            }
+        ],
+        u'extattrs': {
+            u'Account': {u'value': u'8a21c40495f04f30a1b2dc6fd1d9ed1a'},
+            u'Cloud API Owned': {u'value': u'True'},
+            u'VM ID': {u'value': u'None'},
+            u'IP Type': {u'value': u'Fixed'},
+            u'CMP Type': {u'value': u'OpenStack'},
+            u'Port ID': {u'value': u'136ef9ad-9c88-41ea-9fa6-bd48d8ec789a'},
+            u'Tenant ID': {u'value': u'00fd80791dee4112bb538c872b206d4c'}
+        }
+    }
+    """
+    return_fields = [
+        'ipv4addrs',
+        'extattrs'
+    ]
+
+    def __repr__(self):
+        return "HostRecord{0}".format(self.to_dict())
+
+    def __eq__(self, other):
+        return (isinstance(other, self.__class__) and
+                self.ips == other.ips and
+                self.name == other.name and
+                self.dns_view == other.dns_view)
+
+    @property
+    def ip(self):
+        if self.ips:
+            return self.ips[0].ip
+
+    @ip.setter
+    def ip(self, ip_address):
+        if self.ips:
+            self.ips[0].ip = ip_address
+        else:
+            ip_obj = IPv4()
+            ip_obj.ip = ip_address
+
+            self.ips.append(ip_obj)
+
+    @property
+    def mac(self):
+        if self.ips:
+            return self.ips[0].mac
+
+    @mac.setter
+    def mac(self, mac_address):
+        if self.ips:
+            self.ips[0].mac = mac_address
+        else:
+            ip_obj = IPv4()
+            ip_obj.mac = mac_address
+            self.ips.append(ip_obj)
+
+    @property
+    def hostname(self):
+        if self.ips:
+            return self.ips[0].hostname
+
+    @hostname.setter
+    def hostname(self, name):
+        if self.ips:
+            self.ips[0].hostname = name
+        else:
+            ip_obj = IPv4()
+            ip_obj.hostname = name
+            self.ips.append(ip_obj)
+
+    def to_dict(self):
+        result = {
+            'view': self.dns_view,
+            'name': '.'.join([self.hostname, self.zone_auth]),
+            'extattrs': self.extattrs,
+            'ipv4addrs': [ip.to_dict() for ip in self.ips]
+        }
+        return result
+
+    @staticmethod
+    def from_dict(hr_dict):
+        ipv4addrs = hr_dict.get('ipv4addrs', None)
+        if not ipv4addrs:
+            raise ib_exc.HostRecordNotPresent()
+
+        ipv4addr = ipv4addrs[0]
+        ip = ipv4addr['ipv4addr']
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+        host = ipv4addr.get('host', 'unknown.unknown')
+        mac = ipv4addr.get('mac')
+        hostname, _, dns_zone = host.partition('.')
+
+        host_record = HostRecordIPv4()
+        host_record.hostname = hostname
+        host_record.zone_auth = dns_zone
+        host_record.ref = hr_dict.get('_ref')
+        host_record.ips = [IPv4.from_dict(ip) for ip in ipv4addrs]
+        host_record.extattrs = hr_dict.get('extattrs')
+
+        return host_record
+
+    @property
+    def zone_auth(self):
+        if self.ips:
+            return self.ips[0].zone_auth
+
+    @zone_auth.setter
+    def zone_auth(self, value):
+        if value:
+            self.ips[0].zone_auth = value.lstrip('.')
+
+
+class HostRecordIPv6(HostRecord):
+    """Sample Infoblox host record object in JSON format:
+    {
+        u'_ref': u'record:host/ZG5zLmhvc3QkLl9kZWZhdWx0LmNvbS5nbG9iYWwuYMQ
+                   :test_host_name.testsubnet.cloud.global.com/default',
+        u'ipv6addrs': [
+            {
+                u'configure_for_dhcp': False,
+                u'_ref': u'record:host_ipv6addr/ZG5zLmhvc3RfYWRkcmV:2607%3Af0d0%3A1002%3A51%3A%3A2/
+                         test_host_name.testsubnet/default',
+                u'host': u'ea30c45d-6385-44a2-b187-94b0c6f8bad1.9706dd0c-b772-4522-93e3-2e4fea2859de.cloud.global.com',
+                u'duid': u'00:6f:6d:ba:fa:16:3e:86:40:e3',
+                u'ipv6addr': u'2607:f0d0:1002:51::2'
+            }
+        ],
+        u'extattrs': {
+                        u'Account': {u'value': u'8a21c40495f04f30a1b2dc6fd1d9ed1a'},
+                        u'Port ID': {u'value': u'77c2ee08-32bf-4cd6-a24f-586ca91bd533'},
+                        u'VM ID': {u'value': u'None'},
+                        u'IP Type': {u'value': u'Fixed'},
+                        u'CMP Type': {u'value': u'OpenStack'},
+                        u'Cloud API Owned': {u'value': u'True'},
+                        u'Tenant ID': {u'value': u'00fd80791dee4112bb538c872b206d4c'}
+                     }
+    }
+    """
+    return_fields = [
+        'ipv6addrs',
+        'extattrs'
+    ]
+
+    def to_dict(self):
+        result = {
+            'view': self.dns_view,
+            'name': '.'.join([self.hostname, self.zone_auth]),
+            'extattrs': self.extattrs
+        }
+
+        result['ipv6addrs'] = [{
+            'configure_for_dhcp': self.configure_for_dhcp,
+            'ipv6addr': self.ip,
+            'duid': generate_duid(self.mac)
+        }]
+
+        return result
+
+    @staticmethod
+    def from_dict(hr_dict):
+        ipv6addrs = hr_dict.get('ipv6addrs', None)
+        if not ipv6addrs:
+            raise ib_exc.HostRecordNotPresent()
+
+        ipv6addr = ipv6addrs[0]
+        ip = ipv6addr['ipv6addr']
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+        host = ipv6addr.get('host', 'unknown.unknown')
+        mac = ipv6addr.get('mac')
+
+        hostname, _, dns_zone = host.partition('.')
+
+        host_record = HostRecordIPv6()
+        host_record.hostname = hostname
+        host_record.zone_auth = dns_zone
+        host_record.mac = mac
+        host_record.ip = ip
+        host_record.ref = hr_dict.get('_ref')
+
+        return host_record
+
+    @property
+    def ip(self):
+        if self.ips:
+            return self.ips[0].ip
+
+    @ip.setter
+    def ip(self, ip_address):
+        if self.ips:
+            self.ips[0].ip = ip_address
+        else:
+            ip_obj = IPv6()
+            ip_obj.ip = ip_address
+
+            self.ips.append(ip_obj)
+
+    @property
+    def mac(self):
+        if self.ips:
+            return self.ips[0].mac
+
+    @mac.setter
+    def mac(self, mac_address):
+        if self.ips:
+            self.ips[0].mac = mac_address
+        else:
+            ip_obj = IPv6()
+            ip_obj.mac = mac_address
+            self.ips.append(ip_obj)
+
+    @property
+    def hostname(self):
+        if self.ips:
+            return self.ips[0].hostname
+
+    @hostname.setter
+    def hostname(self, name):
+        if self.ips:
+            self.ips[0].hostname = name
+        else:
+            ip_obj = IPv6()
+            ip_obj.hostname = name
+            self.ips.append(ip_obj)
+
+
+class FixedAddress(IPAllocationObject):
+    def __init__(self):
+        self.infoblox_type = 'fixedaddress'
+        self.ip = None
+        self.net_view = None
+        self.mac = None
+        self.duid = None
+        self.extattrs = None
+        self.ref = None
+
+    def __repr__(self):
+        return "FixedAddress({0})".format(self.to_dict())
+
+
+class FixedAddressIPv4(FixedAddress):
+    def __init__(self):
+        self.infoblox_type = 'fixedaddress'
+
+        self.return_fields = [
+            'ipv4addr',
+            'mac',
+            'network_view',
+            'extattrs'
+        ]
+
+    def to_dict(self):
+        return {
+            'mac': self.mac,
+            'network_view': self.net_view,
+            'ipv4addr': self.ip,
+            'extattrs': self.extattrs
+        }
+
+    @staticmethod
+    def from_dict(fixed_address_dict):
+        ip = fixed_address_dict.get('ipv4addr')
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+
+        fa = FixedAddress()
+        fa.ip = ip
+        fa.mac = fixed_address_dict.get('mac')
+        fa.net_view = fixed_address_dict.get('network_view')
+        fa.extattrs = fixed_address_dict.get('extattrs')
+        fa.ref = fixed_address_dict.get('_ref')
+        return fa
+
+
+class FixedAddressIPv6(FixedAddress):
+    def __init__(self):
+        self.infoblox_type = 'ipv6fixedaddress'
+
+        self.return_fields = [
+            'ipv6addr',
+            'duid',
+            'network_view',
+            'extattrs'
+        ]
+
+    def to_dict(self):
+        return {
+            'duid': generate_duid(self.mac),
+            'network_view': self.net_view,
+            'ipv6addr': self.ip,
+            'extattrs': self.extattrs
+        }
+
+    @staticmethod
+    def from_dict(fixed_address_dict):
+        ip = fixed_address_dict.get('ipv6addr')
+        if not is_valid_ip(ip):
+            raise ib_exc.InfobloxInvalidIp(ip=ip)
+
+        fa = FixedAddress()
+        fa.ip = ip
+        fa.mac = fixed_address_dict.get('mac')
+        fa.net_view = fixed_address_dict.get('network_view')
+        fa.extattrs = fixed_address_dict.get('extattrs')
+        fa.ref = fixed_address_dict.get('_ref')
+        return fa
+
+
+class Member(object):
+    def __init__(self, ip, name, ipv6=None, map_id=None, delegate=False):
+        self.ip = ip
+        self.ipv6 = ipv6
+        self.name = name
+        self.map_id = map_id
+        self.delegate = delegate
+
+    def __eq__(self, other):
+        return self.ip == other.ip and \
+            self.name == other.name and \
+            self.map_id == other.map_id
+
+    def __repr__(self):
+        return \
+            ('Member(IP={ip}, IPv6={ipv6}, name={name}, map_id={map_id}, ' +
+            'delegate={delegate})').\
+            format(ip=self.ip,
+                   ipv6=self.ipv6,
+                   name=self.name,
+                   map_id=self.map_id,
+                   delegate=self.delegate)
+
+    @property
+    def specifier(self):
+        """Return _struct dhcpmember that can be used to specify a member"""
+        specifier = {'_struct': 'dhcpmember'}
+        if self.name:
+            specifier['name'] = self.name
+        elif self.ip:
+            specifier['ipv4addr'] = self.ip
+        elif self.ipv6:
+            specifier['ipv6addr'] = self.ipv6
+        return specifier
diff --git a/neutron/ipam/drivers/infoblox/tasks.py b/neutron/ipam/drivers/infoblox/tasks.py
new file mode 100644
index 0000000..56d8d24
--- /dev/null
+++ b/neutron/ipam/drivers/infoblox/tasks.py
@@ -0,0 +1,143 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import operator
+
+from taskflow import task
+
+from neutron.ipam.drivers.infoblox import exceptions
+
+
+class CreateNetViewTask(task.Task):
+    def execute(self, obj_manip, net_view_name, nview_extattrs, dhcp_member):
+        obj_manip.create_network_view(
+                        net_view_name, nview_extattrs, dhcp_member[0])
+
+    def revert(self, obj_manip, net_view_name, **kwargs):
+        if not obj_manip.has_networks(net_view_name):
+            obj_manip.delete_network_view(net_view_name)
+
+
+class CreateNetworkTask(task.Task):
+    def execute(self, obj_manip, net_view_name, cidr, nameservers, dhcp_member,
+                gateway_ip, dhcp_trel_ip, network_extattrs, related_members,
+                ip_version, ipv6_ra_mode=None, ipv6_address_mode=None):
+        obj_manip.create_network(net_view_name, cidr, nameservers, dhcp_member,
+                                 gateway_ip, dhcp_trel_ip, network_extattrs)
+        for member in related_members:
+            obj_manip.restart_all_services(member)
+
+    def revert(self, obj_manip, net_view_name, related_members, cidr,
+               **kwargs):
+        obj_manip.delete_network(net_view_name, cidr)
+        for member in related_members:
+            obj_manip.restart_all_services(member)
+
+
+class ChainInfobloxNetworkTask(task.Task):
+    def execute(self, obj_manip, net_view_name, cidr, network_extattrs):
+        ea_names = ['Is External', 'Is Shared']
+
+        eas = operator.itemgetter(*ea_names)(network_extattrs)
+        shared_or_external = any(eval(ea['value']) for ea in eas)
+
+        if shared_or_external:
+            ib_network = obj_manip.get_network(net_view_name, cidr)
+            obj_manip.update_network_options(ib_network, network_extattrs)
+        else:
+            raise exceptions.InfobloxInternalPrivateSubnetAlreadyExist()
+
+    def revert(self, obj_manip, net_view_name, cidr, network_extattrs,
+               **kwargs):
+        # keep NIOS network untouched on rollback
+        pass
+
+
+class CreateNetworkFromTemplateTask(task.Task):
+    def execute(self, obj_manip, net_view_name, cidr, template,
+                network_extattrs):
+        obj_manip.create_network_from_template(
+            net_view_name, cidr, template, network_extattrs)
+
+    def revert(self, obj_manip, net_view_name, cidr, **kwargs):
+        obj_manip.delete_network(net_view_name, cidr)
+
+
+class CreateIPRange(task.Task):
+    def execute(self, obj_manip, net_view_name, start_ip, end_ip, disable,
+                cidr, range_extattrs, ip_version, ipv6_ra_mode=None,
+                ipv6_address_mode=None):
+        obj_manip.create_ip_range(net_view_name, start_ip, end_ip,
+                                  cidr, disable, range_extattrs)
+
+    def revert(self, obj_manip, net_view_name, start_ip, end_ip,
+               ip_version, ipv6_ra_mode=None, ipv6_address_mode=None,
+               **kwargs):
+        obj_manip.delete_ip_range(net_view_name, start_ip, end_ip)
+
+
+class CreateDNSViewTask(task.Task):
+    def execute(self, obj_manip, net_view_name, dns_view_name):
+        obj_manip.create_dns_view(net_view_name, dns_view_name)
+
+    def revert(self, **kwargs):
+        # never delete DNS view
+        pass
+
+
+class CreateDNSZonesTask(task.Task):
+    def execute(self, obj_manip, dnsview_name, fqdn, dns_member,
+                secondary_dns_members, zone_extattrs, **kwargs):
+        obj_manip.create_dns_zone(dnsview_name, fqdn, dns_member,
+                                  secondary_dns_members,
+                                  zone_extattrs=zone_extattrs)
+
+    def revert(self, obj_manip, dnsview_name, fqdn, **kwargs):
+        obj_manip.delete_dns_zone(dnsview_name, fqdn)
+
+
+class CreateDNSZonesTaskCidr(task.Task):
+    def execute(self, obj_manip, dnsview_name, cidr, dns_member, zone_format,
+                secondary_dns_members, prefix, zone_extattrs, **kwargs):
+        obj_manip.create_dns_zone(dnsview_name, cidr, dns_member,
+                                  secondary_dns_members,
+                                  prefix=prefix,
+                                  zone_format=zone_format,
+                                  zone_extattrs=zone_extattrs)
+
+    def revert(self, obj_manip, dnsview_name, cidr, **kwargs):
+        obj_manip.delete_dns_zone(dnsview_name, cidr)
+
+
+class CreateDNSZonesFromNSGroupTask(task.Task):
+    def execute(self, obj_manip, dnsview_name, fqdn, ns_group,
+                zone_extattrs, **kwargs):
+        obj_manip.create_dns_zone(dnsview_name, fqdn, ns_group=ns_group,
+                                  zone_extattrs=zone_extattrs)
+
+    def revert(self, obj_manip, dnsview_name, fqdn, **kwargs):
+        obj_manip.delete_dns_zone(dnsview_name, fqdn)
+
+
+class CreateDNSZonesCidrFromNSGroupTask(task.Task):
+    def execute(self, obj_manip, dnsview_name, cidr, ns_group, zone_format,
+                prefix, zone_extattrs, **kwargs):
+        obj_manip.create_dns_zone(dnsview_name, cidr,
+                                  ns_group=ns_group,
+                                  prefix=prefix,
+                                  zone_format=zone_format,
+                                  zone_extattrs=zone_extattrs)
+
+    def revert(self, obj_manip, dnsview_name, cidr, **kwargs):
+        obj_manip.delete_dns_zone(dnsview_name, cidr)
diff --git a/neutron/ipam/drivers/neutron_db.py b/neutron/ipam/drivers/neutron_db.py
new file mode 100644
index 0000000..096722b
--- /dev/null
+++ b/neutron/ipam/drivers/neutron_db.py
@@ -0,0 +1,217 @@
+# Copyright (c) 2014 OpenStack Foundation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import netaddr
+
+from sqlalchemy import orm
+from sqlalchemy.orm import exc
+
+from neutron.common import exceptions as n_exc
+from neutron.db import common_db_mixin
+from neutron.db import models_v2
+from neutron.openstack.common import log as logging
+
+
+LOG = logging.getLogger(__name__)
+
+
+class NeutronPluginController(common_db_mixin.CommonDbMixin):
+    def _get_network(self, context, net_id):
+        try:
+            network = self._get_by_id(context, models_v2.Network, net_id)
+        except exc.NoResultFound:
+            raise n_exc.NetworkNotFound(net_id=net_id)
+        return network
+
+    def _get_subnet(self, context, subnet_id):
+        try:
+            subnet = self._get_by_id(context, models_v2.Subnet, subnet_id)
+        except exc.NoResultFound:
+            raise n_exc.SubnetNotFound(subnet_id=subnet_id)
+        return subnet
+
+
+def get_subnets_by_port_id(context, port_id):
+    subnets_with_port = []
+    # Get Requested port
+    port = context.session.query(models_v2.Port).filter_by(id=port_id).one()
+    # Collect all subnets from port network
+    subnets = get_subnets_by_network(context, port.network_id)
+    for sub in subnets:
+        # Collect all ports from subnet
+        subnet_ports = get_subnet_ports(context, sub.id)
+        # Compare them with original port, and if they are the same - save
+        subnets_with_port += [sub for sp in subnet_ports if sp.id == port.id]
+
+    return subnets_with_port
+
+
+def get_subnet_ports(context, subnet_id):
+    # Check if any tenant owned ports are using this subnet
+    ports_qry = context.session.query(models_v2.Port).join(
+        models_v2.IPAllocation).with_lockmode(
+        'update').enable_eagerloads(False)
+    ports = ports_qry.filter_by(subnet_id=subnet_id)
+    return ports
+
+
+def get_all_subnets(context):
+    return context.session.query(models_v2.Subnet).all()
+
+
+def generate_ip(context, subnet):
+    try:
+        return _try_generate_ip(context, subnet)
+    except n_exc.IpAddressGenerationFailure:
+        _rebuild_availability_ranges(context, subnet)
+
+    return _try_generate_ip(context, subnet)
+
+
+def allocate_specific_ip(context, subnet_id, ip_address):
+    """Allocate a specific IP address on the subnet."""
+    ip = int(netaddr.IPAddress(ip_address))
+    range_qry = context.session.query(
+        models_v2.IPAvailabilityRange).join(
+            models_v2.IPAllocationPool).with_lockmode('update')
+    results = range_qry.filter_by(subnet_id=subnet_id)
+    for range in results:
+        first = int(netaddr.IPAddress(range['first_ip']))
+        last = int(netaddr.IPAddress(range['last_ip']))
+        if first <= ip <= last:
+            if first == last:
+                context.session.delete(range)
+                return
+            elif first == ip:
+                range['first_ip'] = str(netaddr.IPAddress(ip_address) + 1)
+                return
+            elif last == ip:
+                range['last_ip'] = str(netaddr.IPAddress(ip_address) - 1)
+                return
+            else:
+                # Split into two ranges
+                new_first = str(netaddr.IPAddress(ip_address) + 1)
+                new_last = range['last_ip']
+                range['last_ip'] = str(netaddr.IPAddress(ip_address) - 1)
+                ip_range = models_v2.IPAvailabilityRange(
+                    allocation_pool_id=range['allocation_pool_id'],
+                    first_ip=new_first,
+                    last_ip=new_last)
+                context.session.add(ip_range)
+                return ip_address
+        return None
+
+
+def get_dns_by_subnet(context, subnet_id):
+    dns_qry = context.session.query(models_v2.DNSNameServer)
+    return dns_qry.filter_by(subnet_id=subnet_id).all()
+
+
+def get_route_by_subnet(context, subnet_id):
+    route_qry = context.session.query(models_v2.SubnetRoute)
+    return route_qry.filter_by(subnet_id=subnet_id).all()
+
+
+def get_subnets_by_network(context, network_id):
+    subnet_qry = context.session.query(models_v2.Subnet)
+    return subnet_qry.filter_by(network_id=network_id).all()
+
+
+def _try_generate_ip(context, subnet):
+    """Generate an IP address.
+
+    The IP address will be generated from one of the subnets defined on
+    the network.
+    """
+    if type(subnet) is list:
+        subnet = subnet[0]
+    range_qry = context.session.query(
+        models_v2.IPAvailabilityRange).join(
+            models_v2.IPAllocationPool).with_lockmode('update')
+    range = range_qry.filter_by(subnet_id=subnet.id).first()
+    if not range:
+        LOG.debug(_("All IPs from subnet %(subnet_id)s (%(cidr)s) "
+                    "allocated"),
+                  {'subnet_id': subnet.id,
+                   'cidr': subnet.cidr})
+        raise n_exc.IpAddressGenerationFailure(
+            net_id=subnet['network_id'])
+    ip_address = range['first_ip']
+    LOG.debug(_("Allocated IP - %(ip_address)s from %(first_ip)s "
+                "to %(last_ip)s"),
+              {'ip_address': ip_address,
+               'first_ip': range['first_ip'],
+               'last_ip': range['last_ip']})
+    if range['first_ip'] == range['last_ip']:
+        # No more free indices on subnet => delete
+        LOG.debug(_("No more free IP's in slice. Deleting allocation "
+                    "pool."))
+        context.session.delete(range)
+    else:
+        # increment the first free
+        range['first_ip'] = str(netaddr.IPAddress(ip_address) + 1)
+    return {'ip_address': ip_address, 'subnet_id': subnet.id}
+
+
+def _rebuild_availability_ranges(context, subnets):
+    """Rebuild availability ranges.
+
+    This method is called only when there's no more IP available or by
+    _update_subnet_allocation_pools. Calling
+    _update_subnet_allocation_pools before calling this function deletes
+    the IPAllocationPools associated with the subnet that is updating,
+    which will result in deleting the IPAvailabilityRange too.
+    """
+    ip_qry = context.session.query(
+        models_v2.IPAllocation).with_lockmode('update')
+    # PostgreSQL does not support select...for update with an outer join.
+    # No join is needed here.
+    pool_qry = context.session.query(
+        models_v2.IPAllocationPool).options(
+            orm.noload('available_ranges')).with_lockmode('update')
+    for subnet in sorted(subnets):
+        LOG.debug(_("Rebuilding availability ranges for subnet %s")
+                  % subnet)
+
+        # Create a set of all currently allocated addresses
+        ip_qry_results = ip_qry.filter_by(subnet_id=subnet['id'])
+        allocations = netaddr.IPSet([netaddr.IPAddress(i['ip_address'])
+                                    for i in ip_qry_results])
+
+        for pool in pool_qry.filter_by(subnet_id=subnet['id']):
+            # Create a set of all addresses in the pool
+            poolset = netaddr.IPSet(netaddr.iter_iprange(pool['first_ip'],
+                                                         pool['last_ip']))
+
+            # Use set difference to find free addresses in the pool
+            available = poolset - allocations
+
+            # Generator compacts an ip set into contiguous ranges
+            def ipset_to_ranges(ipset):
+                first, last = None, None
+                for cidr in ipset.iter_cidrs():
+                    if last and last + 1 != cidr.first:
+                        yield netaddr.IPRange(first, last)
+                        first = None
+                    first, last = first if first else cidr.first, cidr.last
+                if first:
+                    yield netaddr.IPRange(first, last)
+
+            # Write the ranges to the db
+            for ip_range in ipset_to_ranges(available):
+                available_range = models_v2.IPAvailabilityRange(
+                    allocation_pool_id=pool['id'],
+                    first_ip=str(netaddr.IPAddress(ip_range.first)),
+                    last_ip=str(netaddr.IPAddress(ip_range.last)))
+                context.session.add(available_range)
diff --git a/neutron/ipam/drivers/neutron_ipam.py b/neutron/ipam/drivers/neutron_ipam.py
new file mode 100755
index 0000000..5df01ce
--- /dev/null
+++ b/neutron/ipam/drivers/neutron_ipam.py
@@ -0,0 +1,449 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from neutron.api.v2 import attributes
+from neutron.common import constants
+from neutron.common import exceptions as q_exc
+from neutron.db import models_v2
+from neutron.ipam import base
+from neutron.ipam.drivers import neutron_db
+from neutron.openstack.common import log as logging
+from neutron.openstack.common import uuidutils
+
+LOG = logging.getLogger(__name__)
+
+
+class NeutronIPAMController(base.IPAMController):
+    def _make_allocation_pools(self, context, backend_subnet, subnet):
+        # Store information about allocation pools and ranges
+        for pool in subnet['allocation_pools']:
+            ip_pool = models_v2.IPAllocationPool(subnet=backend_subnet,
+                                                 first_ip=pool['start'],
+                                                 last_ip=pool['end'])
+            context.session.add(ip_pool)
+            ip_range = models_v2.IPAvailabilityRange(
+                ipallocationpool=ip_pool,
+                first_ip=pool['start'],
+                last_ip=pool['end'])
+            context.session.add(ip_range)
+
+    def create_subnet(self, context, subnet):
+        tenant_id = self._get_tenant_id_for_create(context, subnet)
+        network = self._get_network(context, subnet['network_id'])
+
+        # The 'shared' attribute for subnets is for internal plugin
+        # use only. It is not exposed through the API
+        args = {'tenant_id': tenant_id,
+                'id': subnet.get('id') or uuidutils.generate_uuid(),
+                'name': subnet['name'],
+                'network_id': subnet['network_id'],
+                'ip_version': subnet['ip_version'],
+                'cidr': subnet['cidr'],
+                'enable_dhcp': subnet['enable_dhcp'],
+                'gateway_ip': subnet['gateway_ip'],
+                'shared': network.shared}
+        if subnet['ip_version'] == 6 and subnet['enable_dhcp']:
+            if attributes.is_attr_set(subnet.get('ipv6_ra_mode')):
+                args['ipv6_ra_mode'] = subnet['ipv6_ra_mode']
+            if attributes.is_attr_set(subnet.get('ipv6_address_mode')):
+                args['ipv6_address_mode'] = subnet['ipv6_address_mode']
+        backend_subnet = models_v2.Subnet(**args)
+
+        self._make_allocation_pools(context, backend_subnet, subnet)
+        context.session.add(backend_subnet)
+
+        return self._make_subnet_dict(backend_subnet)
+
+    def create_network(self, context, network):
+        return network
+
+    def get_subnet_by_id(self, context, subnet_id):
+        return self._get_subnet(context, subnet_id)
+
+    def update_subnet(self, context, subnet_id, subnet):
+        backend_subnet = self.get_subnet_by_id(context, subnet_id)
+        return backend_subnet
+
+    def _make_subnet_dict(self, subnet, fields=None):
+        res = {'id': subnet['id'],
+               'name': subnet['name'],
+               'tenant_id': subnet['tenant_id'],
+               'network_id': subnet['network_id'],
+               'ip_version': subnet['ip_version'],
+               'cidr': subnet['cidr'],
+               'allocation_pools': [{'start': pool['first_ip'],
+                                     'end': pool['last_ip']}
+                                    for pool in subnet['allocation_pools']],
+               'gateway_ip': subnet['gateway_ip'],
+               'enable_dhcp': subnet['enable_dhcp'],
+               'ipv6_ra_mode': subnet['ipv6_ra_mode'],
+               'ipv6_address_mode': subnet['ipv6_address_mode'],
+               'dns_nameservers': [dns['address']
+                                   for dns in subnet['dns_nameservers']],
+               'host_routes': [{'destination': route['destination'],
+                                'nexthop': route['nexthop']}
+                               for route in subnet['routes']],
+               'shared': subnet['shared']
+               }
+        # Call auxiliary extend functions, if any
+        self._apply_dict_extend_functions(attributes.SUBNETS, res, subnet)
+
+        return self._fields(res, fields)
+
+    def get_subnets(self, context, filters=None, fields=None,
+                    sorts=None, limit=None, marker=None,
+                    page_reverse=False):
+        marker_obj = self._get_marker_obj(context, 'subnet', limit, marker)
+        return self._get_collection(context, models_v2.Subnet,
+                                    self._make_subnet_dict,
+                                    filters=filters, fields=fields,
+                                    sorts=sorts,
+                                    limit=limit,
+                                    marker_obj=marker_obj,
+                                    page_reverse=page_reverse)
+
+    def get_subnets_count(self, context, filters=None):
+        return self._get_collection_count(context, models_v2.Subnet,
+                                          filters=filters)
+
+    def delete_subnet(self, context, backend_subnet):
+        pass
+
+    def force_off_ports(self, context, ports):
+        """Force Off ports on subnet delete event."""
+        for port in ports:
+            query = (context.session.query(models_v2.Port).
+                     enable_eagerloads(False).filter_by(id=port.id))
+            if not context.is_admin:
+                query = query.filter_by(tenant_id=context.tenant_id)
+
+            query.delete()
+
+    def allocate_ip(self, context, subnet, host, ip=None):
+        if ip is not None and 'ip_address' in ip:
+            subnet_id = subnet['id']
+            ip_address = {'subnet_id': subnet_id,
+                          'ip_address': ip['ip_address']}
+            neutron_db.allocate_specific_ip(
+                context, subnet_id, ip['ip_address'])
+            return ip_address
+        else:
+            subnets = [subnet]
+            return neutron_db.generate_ip(context, subnets)
+
+    def deallocate_ip(self, context, backend_subnet, host, ip_address):
+        # IPAllocations are automatically handled by cascade deletion
+        pass
+
+    def delete_network(self, context, network_id):
+        pass
+
+    def set_dns_nameservers(self, context, port):
+        pass
+
+
+class NeutronDHCPController(base.DHCPController):
+    def __init__(self, db_mgr=None):
+        if db_mgr is None:
+            db_mgr = neutron_db
+
+        self.db_manager = db_mgr
+
+    def configure_dhcp(self, context, backend_subnet, dhcp_params):
+        # Store information about DNS Servers
+        if dhcp_params['dns_nameservers'] is not attributes.ATTR_NOT_SPECIFIED:
+            for addr in dhcp_params['dns_nameservers']:
+                ns = models_v2.DNSNameServer(address=addr,
+                                             subnet_id=backend_subnet['id'])
+                context.session.add(ns)
+                backend_subnet['dns_nameservers'].append(addr)
+
+        # Store host routes
+        if dhcp_params['host_routes'] is not attributes.ATTR_NOT_SPECIFIED:
+            for rt in dhcp_params['host_routes']:
+                route = models_v2.SubnetRoute(
+                    subnet_id=backend_subnet['id'],
+                    destination=rt['destination'],
+                    nexthop=rt['nexthop'])
+                context.session.add(route)
+                backend_subnet['host_routes'].append({
+                    'destination': rt['destination'],
+                    'nexthop': rt['nexthop']})
+
+    def reconfigure_dhcp(self, context, backend_subnet, dhcp_params):
+        changed_dns = False
+        new_dns = []
+        if "dns_nameservers" in dhcp_params:
+            changed_dns = True
+            old_dns_list = self.db_manager.get_dns_by_subnet(
+                context, backend_subnet['id'])
+            new_dns_addr_set = set(dhcp_params["dns_nameservers"])
+            old_dns_addr_set = set([dns['address']
+                                    for dns in old_dns_list])
+
+            new_dns = list(new_dns_addr_set)
+            for dns_addr in old_dns_addr_set - new_dns_addr_set:
+                for dns in old_dns_list:
+                    if dns['address'] == dns_addr:
+                        context.session.delete(dns)
+            for dns_addr in new_dns_addr_set - old_dns_addr_set:
+                dns = models_v2.DNSNameServer(
+                    address=dns_addr,
+                    subnet_id=backend_subnet['id'])
+                context.session.add(dns)
+
+            if len(dhcp_params['dns_nameservers']):
+                del dhcp_params['dns_nameservers']
+
+        def _combine(ht):
+            return ht['destination'] + "_" + ht['nexthop']
+
+        changed_host_routes = False
+        new_routes = []
+        if "host_routes" in dhcp_params:
+            changed_host_routes = True
+            old_route_list = self.db_manager.get_route_by_subnet(
+                context, backend_subnet['id'])
+
+            new_route_set = set([_combine(route)
+                                 for route in dhcp_params['host_routes']])
+
+            old_route_set = set([_combine(route)
+                                 for route in old_route_list])
+
+            for route_str in old_route_set - new_route_set:
+                for route in old_route_list:
+                    if _combine(route) == route_str:
+                        context.session.delete(route)
+            for route_str in new_route_set - old_route_set:
+                route = models_v2.SubnetRoute(
+                    destination=route_str.partition("_")[0],
+                    nexthop=route_str.partition("_")[2],
+                    subnet_id=backend_subnet['id'])
+                context.session.add(route)
+
+            # Gather host routes for result
+            for route_str in new_route_set:
+                new_routes.append(
+                    {'destination': route_str.partition("_")[0],
+                     'nexthop': route_str.partition("_")[2]})
+            del dhcp_params['host_routes']
+
+        backend_subnet.update(dhcp_params)
+
+        result = {}
+        if changed_dns:
+            result['new_dns'] = new_dns
+        if changed_host_routes:
+            result['new_routes'] = new_routes
+        return result
+
+    def bind_mac(self, context, backend_subnet, ip_address, mac_address):
+        pass
+
+    def unbind_mac(self, context, backend_subnet, ip_address):
+        pass
+
+    def dhcp_is_enabled(self, context, backend_subnet):
+        pass
+
+    def disable_dhcp(self, context, backend_subnet):
+        pass
+
+    def get_dhcp_ranges(self, context, backend_subnet):
+        pass
+
+
+class NeutronDNSController(base.DNSController):
+    """DNS controller for standard neutron behavior is not implemented because
+    neutron does not provide that functionality
+    """
+    def bind_names(self, context, backend_port):
+        pass
+
+    def unbind_names(self, context, backend_port):
+        pass
+
+    def create_dns_zones(self, context, backend_subnet):
+        pass
+
+    def delete_dns_zones(self, context, backend_subnet):
+        pass
+
+    def disassociate_floatingip(self, context, floatingip, port_id):
+        pass
+
+
+class NeutronIPAM(base.IPAMManager):
+    def __init__(self, dhcp_controller=None, dns_controller=None,
+                 ipam_controller=None, db_mgr=None):
+        # These should be initialized in derived DDI class
+        if dhcp_controller is None:
+            dhcp_controller = NeutronDHCPController()
+
+        if dns_controller is None:
+            dns_controller = NeutronDNSController()
+
+        if ipam_controller is None:
+            ipam_controller = NeutronIPAMController()
+
+        if db_mgr is None:
+            db_mgr = neutron_db
+
+        self.dns_controller = dns_controller
+        self.ipam_controller = ipam_controller
+        self.dhcp_controller = dhcp_controller
+        self.db_manager = db_mgr
+
+    def create_subnet(self, context, subnet):
+        with context.session.begin(subtransactions=True):
+            # Allocate IP addresses. Create allocation pools only
+            backend_subnet = self.ipam_controller.create_subnet(context,
+                                                                subnet)
+            self.dns_controller.create_dns_zones(context, backend_subnet)
+            # Configure DHCP
+            dhcp_params = subnet
+            self.dhcp_controller.configure_dhcp(context, backend_subnet,
+                                                dhcp_params)
+
+            self.ipam_controller.get_subnet_by_id(context,
+                                                  backend_subnet['id'])
+            return backend_subnet
+
+    def update_subnet(self, context, subnet_id, subnet):
+        with context.session.begin(subtransactions=True):
+            backend_subnet = self.ipam_controller.update_subnet(
+                context, subnet_id, subnet)
+
+            # Reconfigure DHCP for subnet
+            dhcp_params = subnet
+            dhcp_changes = self.dhcp_controller.reconfigure_dhcp(
+                context, backend_subnet, dhcp_params)
+
+            return backend_subnet, dhcp_changes
+
+    def delete_subnet(self, context, subnet):
+        if isinstance(subnet, models_v2.Subnet):
+            subnet_id = subnet.id
+        else:
+            subnet_id = subnet
+
+        with context.session.begin(subtransactions=True):
+            backend_subnet = self.ipam_controller.get_subnet_by_id(context,
+                                                                   subnet_id)
+            subnet_ports = self.db_manager.get_subnet_ports(context, subnet_id)
+
+            ports_to_remove = [port for port in subnet_ports if
+                               neutron_db.get_subnets_by_port_id(
+                                   context, port.id) <= 1]
+
+            has_ports_allocated = not all(
+                p.device_owner == constants.DEVICE_OWNER_DHCP
+                for p in subnet_ports)
+
+            if has_ports_allocated:
+                raise q_exc.SubnetInUse(subnet_id=backend_subnet['id'])
+
+            self.ipam_controller.force_off_ports(context, ports_to_remove)
+            self.dns_controller.delete_dns_zones(context, backend_subnet)
+            self.dhcp_controller.disable_dhcp(context, backend_subnet)
+            self.ipam_controller.delete_subnet(context, backend_subnet)
+
+            return subnet_id
+
+    def delete_subnets_by_network(self, context, network_id):
+        with context.session.begin(subtransactions=True):
+            subnets = neutron_db.get_subnets_by_network(
+                context, network_id)
+            for subnet in subnets:
+                self.delete_subnet(context, subnet['id'])
+
+    def get_subnet_by_id(self, context, subnet_id):
+        with context.session.begin(subtransactions=True):
+            return self.ipam_controller.get_subnet_by_id(context, subnet_id)
+
+    def allocate_ip(self, context, host, ip):
+        with context.session.begin(subtransactions=True):
+            subnet_id = ip.get('subnet_id', None)
+            if not subnet_id:
+                LOG.debug(_("ip object must have %(subnet_id)s") % subnet_id)
+                raise
+            backend_subnet = self.ipam_controller.get_subnet_by_id(context,
+                                                                   subnet_id)
+            ip_address = self.ipam_controller.allocate_ip(
+                context,
+                backend_subnet,
+                host,
+                ip)
+
+            LOG.debug('IPAMManager allocate IP: %s' % ip_address)
+            mac_address = host['mac_address']
+            self.dhcp_controller.bind_mac(
+                context,
+                backend_subnet,
+                ip_address,
+                mac_address)
+            return ip_address
+
+    def deallocate_ip(self, context, host, ip):
+        with context.session.begin(subtransactions=True):
+            subnet_id = ip['subnet_id']
+            ip_address = ip['ip_address']
+            backend_subnet = self.ipam_controller.get_subnet_by_id(
+                context, subnet_id)
+            self.dhcp_controller.unbind_mac(
+                context,
+                backend_subnet,
+                ip_address)
+            self.ipam_controller.deallocate_ip(
+                context,
+                backend_subnet,
+                host,
+                ip_address)
+
+    def get_subnets(self, context, filters=None, fields=None,
+                    sorts=None, limit=None, marker=None,
+                    page_reverse=False):
+        return self.ipam_controller.get_subnets(context, filters, fields,
+                                                sorts, limit, marker,
+                                                page_reverse)
+
+    def create_network(self, context, network):
+        return self.ipam_controller.create_network(context, network)
+
+    def delete_network(self, context, network_id):
+        self.ipam_controller.delete_network(
+            context, network_id)
+
+    def create_port(self, context, port):
+        self.dns_controller.bind_names(context, port)
+        if constants.DEVICE_OWNER_DHCP == port['device_owner']:
+            self.ipam_controller.set_dns_nameservers(context, port)
+
+    def update_port(self, context, port):
+        self.dns_controller.bind_names(context, port)
+
+    def delete_port(self, context, port):
+        self.dns_controller.unbind_names(context, port)
+
+    def associate_floatingip(self, context, floatingip, port):
+        self.create_port(context, port)
+
+    def disassociate_floatingip(self, context, floatingip, port_id):
+        self.dns_controller.disassociate_floatingip(context, floatingip,
+                                                    port_id)
+
+    def get_additional_network_dict_params(self, ctx, network_id):
+        return {}
diff --git a/neutron/manager.py b/neutron/manager.py
index 3a21f61..6986a34 100644
--- a/neutron/manager.py
+++ b/neutron/manager.py
@@ -123,6 +123,11 @@ class NeutronManager(object):
         # the rest of service plugins
         self.service_plugins = {constants.CORE: self.plugin}
         self._load_service_plugins()
+        # Load IPAMManager driver
+        ipam_driver_name = cfg.CONF.ipam_driver
+        LOG.info(_("Loading ipam driver: %s"), ipam_driver_name)
+        self.ipam = self._get_plugin_instance('neutron.ipam_drivers',
+                                              ipam_driver_name)
 
     def _get_plugin_instance(self, namespace, plugin_provider):
         try:
@@ -223,3 +228,7 @@ class NeutronManager(object):
         # Return weakrefs to minimize gc-preventing references.
         return dict((x, weakref.proxy(y))
                     for x, y in cls.get_instance().service_plugins.iteritems())
+
+    @classmethod
+    def get_ipam(cls):
+        return cls.get_instance().ipam
diff --git a/neutron/plugins/ml2/plugin.py b/neutron/plugins/ml2/plugin.py
index 9dcf6f8..1fb3160 100644
--- a/neutron/plugins/ml2/plugin.py
+++ b/neutron/plugins/ml2/plugin.py
@@ -650,6 +650,10 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
                             mech_context)
 
                         self.type_manager.release_network_segments(session, id)
+
+                        manager.NeutronManager.get_ipam().delete_network(
+                            context, id)
+
                         record = self._get_network(context, id)
                         LOG.debug(_("Deleting network record %s"), record)
                         session.delete(record)
@@ -766,6 +770,9 @@ class Ml2Plugin(db_base_plugin_v2.NeutronDbPluginV2,
                     self.mechanism_manager.delete_subnet_precommit(
                         mech_context)
 
+                    manager.NeutronManager.get_ipam().delete_subnet(
+                        context, id)
+
                     LOG.debug(_("Deleting subnet record"))
                     session.delete(record)
 
diff --git a/neutron/tests/unit/agent/linux/test_dhcp_relay.py b/neutron/tests/unit/agent/linux/test_dhcp_relay.py
new file mode 100644
index 0000000..576ad82
--- /dev/null
+++ b/neutron/tests/unit/agent/linux/test_dhcp_relay.py
@@ -0,0 +1,63 @@
+# Copyright 2014 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+import mock
+
+from neutron.agent.linux import dhcp_relay
+
+from neutron.agent.common import config
+from neutron.common import exceptions as exc
+from neutron.tests import base
+
+
+class DhcpDnsProxyTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(DhcpDnsProxyTestCase, self).setUp()
+
+    def _get_config(self):
+        conf = mock.MagicMock()
+        conf.interface_driver = "neutron.agent.linux.interface.NullDriver"
+        config.register_interface_driver_opts_helper(conf)
+        return conf
+
+    def test_raises_exception_on_unset_config_options(self):
+        conf = self._get_config()
+        network = mock.Mock()
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy, conf, network)
+
+    def test_implements_get_isolated_subnets(self):
+        network = mock.Mock()
+        conf = self._get_config()
+        conf.external_dhcp_servers = ['1.1.1.1']
+        conf.external_dns_servers = ['1.1.1.2']
+
+        proxy = dhcp_relay.DhcpDnsProxy(conf, network)
+        try:
+            self.assertTrue(callable(proxy.get_isolated_subnets))
+        except AttributeError as ex:
+            self.fail(ex)
+
+    def test_implements_should_enable_metadata(self):
+        network = mock.Mock()
+        conf = self._get_config()
+        conf.external_dhcp_servers = ['1.1.1.1']
+        conf.external_dns_servers = ['1.1.1.2']
+
+        proxy = dhcp_relay.DhcpDnsProxy(conf, network)
+
+        try:
+            self.assertTrue(callable(proxy.should_enable_metadata))
+        except AttributeError as ex:
+            self.fail(ex)
diff --git a/neutron/tests/unit/ipam/__init__.py b/neutron/tests/unit/ipam/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/tests/unit/ipam/drivers/__init__.py b/neutron/tests/unit/ipam/drivers/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/__init__.py b/neutron/tests/unit/ipam/drivers/infoblox/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_config.py b/neutron/tests/unit/ipam/drivers/infoblox/test_config.py
new file mode 100755
index 0000000..1959efe
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_config.py
@@ -0,0 +1,714 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import io
+import operator
+
+import mock
+from testtools import matchers
+
+from neutron.db.infoblox import infoblox_db
+from neutron.db.infoblox import models
+from neutron.ipam.drivers.infoblox import config
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import objects
+from neutron.openstack.common import jsonutils
+from neutron.tests import base
+
+
+class ConfigFinderTestCase(base.BaseTestCase):
+    def test_config_reads_data_from_json(self):
+        valid_config = """
+            [
+                {
+                    "condition": "tenant",
+                    "is_external": false,
+                    "network_view": "{tenant_id}",
+                    "dhcp_members":  "next-available-member",
+                    "require_dhcp_relay":  true,
+                    "domain_suffix_pattern": "local.test.com",
+                    "hostname_pattern": "%{instance_id}"
+                },
+                {
+                    "condition": "global",
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "%{instance_id}"
+                }
+            ]
+        """
+
+        subnet = {
+            'network_id': 'some-net-id',
+            'cidr': '192.168.1.0/24',
+            'tenant_id': 'some-tenant-id'
+        }
+        context = mock.MagicMock()
+
+        cfg = config.ConfigFinder(stream=io.BytesIO(valid_config),
+                                  member_manager=mock.Mock())
+        cfg.configure_members = mock.Mock()
+        subnet_config = cfg.find_config_for_subnet(context, subnet)
+
+        self.assertIsNotNone(subnet_config)
+        self.assertIsInstance(subnet_config, config.Config)
+
+    def test_throws_error_on_invalid_configuration(self):
+        invalid_config = """
+            [
+                {
+                    "condition": "tenant",
+                    "is_external": false,
+                    "network_view": "{tenant_id}",
+                    "dhcp_members":  "next-available-member",
+                    "require_dhcp_relay":  True,
+                    "domain_suffix_pattern": "local.test.com",
+                    "hostname_pattern": "{instance_id}"
+                },
+                {
+                    "condition": "global"
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{instance_id}"
+                }
+            ]
+        """
+
+        # configuration is considered invalid if JSON parser has failed
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          config.ConfigFinder,
+                          stream=io.BytesIO(invalid_config),
+                          member_manager=mock.Mock())
+
+    @mock.patch('neutron.db.infoblox.infoblox_db.is_network_external')
+    def test_external_network_matches_first_external_config(self, is_external):
+        expected_condition = 'global'
+        external_config = """
+            [
+                {{
+                    "condition": "tenant",
+                    "is_external": false,
+                    "network_view": "{{tenant_id}}",
+                    "dhcp_members":  "next-available-member",
+                    "require_dhcp_relay":  true,
+                    "domain_suffix_pattern": "local.test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "{expected_condition:s}",
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "tenant",
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }}
+            ]
+        """.format(**locals())
+        context = mock.Mock()
+        subnet = {
+            'network_id': 'some-net-id',
+            'cidr': '192.168.1.0/24',
+            'tenant_id': 'some-tenant-id'
+        }
+        is_external.return_value = True
+        cfg = config.ConfigFinder(stream=io.BytesIO(external_config),
+                                  member_manager=mock.Mock())
+        cfg._is_member_registered = mock.Mock(return_value=True)
+        config_for_subnet = cfg.find_config_for_subnet(context, subnet)
+
+        self.assertThat(config_for_subnet.condition,
+                        matchers.Equals(expected_condition))
+
+    @mock.patch('neutron.db.infoblox.infoblox_db.is_network_external')
+    def test_subnet_range_condition_matches(self, is_external):
+        expected_cidr = '10.0.0.0/24'
+        expected_condition = 'subnet_range:{0}'.format(expected_cidr)
+        external_config = """
+            [
+                {{
+                    "condition": "{expected_condition:s}",
+                    "is_external": false,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "tenant",
+                    "is_external": false,
+                    "network_view": "{{tenant_id}}",
+                    "dhcp_members":  "next-available-member",
+                    "require_dhcp_relay":  true,
+                    "domain_suffix_pattern": "local.test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "tenant",
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }}
+            ]
+        """.format(**locals())
+        context = mock.Mock()
+        subnet = {
+            'network_id': 'some-net-id',
+            'cidr': expected_cidr,
+            'tenant_id': 'some-tenant-id'
+        }
+        is_external.return_value = False
+        cfg = config.ConfigFinder(stream=io.BytesIO(external_config),
+                                  member_manager=mock.Mock())
+        cfg._is_member_registered = mock.Mock(return_value=True)
+        config_for_subnet = cfg.find_config_for_subnet(context, subnet)
+
+        self.assertThat(config_for_subnet.condition,
+                        matchers.Equals(expected_condition))
+
+    @mock.patch('neutron.db.infoblox.infoblox_db.is_network_external')
+    def test_tenant_id_condition_matches(self, is_external_mock):
+        expected_tenant_id = 'some-tenant-id'
+        expected_condition = 'tenant_id:{0}'.format(expected_tenant_id)
+        tenant_id_conf = """
+            [
+                {{
+                    "condition": "{expected_condition:s}",
+                    "is_external": false,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "global",
+                    "is_external": false,
+                    "network_view": "{{tenant_id}}",
+                    "dhcp_members":  "next-available-member",
+                    "require_dhcp_relay":  true,
+                    "domain_suffix_pattern": "local.test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }},
+                {{
+                    "condition": "tenant",
+                    "is_external": true,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }}
+            ]
+        """.format(**locals())
+        context = mock.Mock()
+        subnet = {
+            'network_id': 'some-net-id',
+            'cidr': '10.0.0.0/24',
+            'tenant_id': expected_tenant_id
+        }
+        is_external_mock.return_value = False
+        cfg = config.ConfigFinder(stream=io.BytesIO(tenant_id_conf),
+                                  member_manager=mock.Mock())
+        cfg._is_member_registered = mock.Mock(return_value=True)
+        config_for_subnet = cfg.find_config_for_subnet(context, subnet)
+
+        self.assertThat(config_for_subnet.condition,
+                        matchers.Equals(expected_condition))
+
+    def test_raises_on_invalid_condition(self):
+        config_template = """
+            [
+                {{
+                    "condition": "{condition}",
+                    "is_external": false,
+                    "dhcp_members":  "member1.infoblox.com",
+                    "domain_suffix_pattern": "test.com",
+                    "hostname_pattern": "{{instance_id}}"
+                }}
+            ]
+        """
+
+        member_manager = mock.Mock()
+        for valid in config.ConfigFinder.VALID_CONDITIONS:
+            valid_conf = config_template.format(condition=valid)
+            try:
+                config.ConfigFinder(io.BytesIO(valid_conf), member_manager)
+            except exceptions.InfobloxConfigException as e:
+                msg = 'Unexpected {error_type} for {config}'.format(
+                    error_type=type(e), config=valid_conf)
+                self.fail(msg)
+
+        invalid_cof = config_template.format(condition='invalid-condition')
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          config.ConfigFinder, io.BytesIO(invalid_cof),
+                          member_manager)
+
+    def test_raises_if_no_suitable_config_found(self):
+        cfg = """
+            [
+                {
+                    "condition": "tenant_id:wrong-id",
+                    "is_external": false
+                }
+            ]
+        """
+        context = mock.MagicMock()
+        subnet = mock.MagicMock()
+
+        cf = config.ConfigFinder(io.BytesIO(cfg), member_manager=mock.Mock())
+        cf._is_member_registered = mock.Mock(return_value=True)
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          cf.find_config_for_subnet, context, subnet)
+
+
+class ConfigTestCase(base.BaseTestCase):
+    def test_exception_raised_on_missing_condition(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          config.Config, {}, context, subnet,
+                          member_manager=mock.Mock())
+
+    def test_default_values_are_set(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        cfg = config.Config({'condition': 'global'}, context, subnet,
+                            member_manager=mock.Mock())
+
+        self.assertFalse(cfg.is_external)
+        self.assertFalse(cfg.require_dhcp_relay)
+        self.assertEqual(cfg.network_view, 'default')
+        self.assertEqual(cfg.dns_view, 'default')
+        self.assertIsNone(cfg.network_template)
+        self.assertIsNone(cfg.ns_group)
+        self.assertEqual(cfg.hostname_pattern,
+                         'host-{ip_address}.{subnet_name}')
+        self.assertEqual(cfg.domain_suffix_pattern, 'global.com')
+
+    def test_dhcp_member_is_returned_as_is_if_explicitly_set(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        expected_member_name = 'some-dhcp-member.com'
+        expected_dhcp_member = [objects.Member(name=expected_member_name,
+                                               ip='some-ip')]
+
+        conf_dict = {
+            'condition': 'global',
+            'dhcp_members': expected_member_name
+        }
+
+        member_manager = mock.Mock()
+        member_manager.find_members.return_value = expected_dhcp_member
+        cfg = config.Config(conf_dict, context, subnet, member_manager)
+
+        self.assertEqual(cfg.dhcp_members, expected_dhcp_member)
+        assert member_manager.find_members.called
+        assert not member_manager.next_available.called
+        assert not member_manager.reserve_member.called
+
+    def test_dhcp_member_is_taken_from_member_config_if_next_available(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        expected_member = objects.Member('some-member-ip', 'some-member-name')
+
+        member_manager = mock.Mock()
+        member_manager.find_members.return_value = None
+        member_manager.next_available.return_value = expected_member
+
+        conf_dict = {
+            'condition': 'global',
+            'dhcp_members': config.Config.NEXT_AVAILABLE_MEMBER
+        }
+
+        cfg = config.Config(conf_dict, context, subnet, member_manager)
+        members = cfg.reserve_dhcp_members()
+        self.assertEqual(members[0], expected_member)
+        assert member_manager.find_members.called_once
+        assert member_manager.next_available.called_once
+        assert member_manager.reserve_meber.called_once
+
+    def test_dns_view_joins_net_view_with_default_if_not_default(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+        member_manager = mock.Mock()
+
+        expected_net_view = 'non-default-net-view'
+        conf_dict = {
+            'condition': 'global',
+            'network_view': expected_net_view,
+        }
+
+        cfg = config.Config(conf_dict, context, subnet, member_manager)
+
+        self.assertTrue(cfg.dns_view.startswith('default'))
+        self.assertTrue(cfg.dns_view.endswith(expected_net_view))
+
+    def test_dns_view_is_default_if_netview_is_default(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+        member_manager = mock.Mock()
+
+        conf_dict = {
+            'condition': 'global',
+            'network_view': 'default',
+        }
+
+        cfg = config.Config(conf_dict, context, subnet, member_manager)
+
+        self.assertThat(cfg.dns_view, matchers.Equals(cfg.network_view))
+
+    def test_configured_value_is_returned_for_dns_view(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+        member_manager = mock.Mock()
+
+        expected_dns_view = 'some-dns-view'
+        conf_dict = {
+            'condition': 'global',
+            'dns_view': expected_dns_view
+        }
+
+        cfg = config.Config(conf_dict, context, subnet, member_manager)
+        self.assertEqual(cfg.dns_view, expected_dns_view)
+
+    def test_reserve_dns_members_always_returns_list(self):
+        configs = [
+            {
+                'dns_members': 'member1',
+                'condition': 'global'
+            },
+            {
+                'dns_members': ['member1', 'member2'],
+                'condition': 'global'
+            },
+            {
+                'condition': 'global'
+            }
+        ]
+        context = mock.Mock()
+        subnet = mock.Mock()
+        member_manager = mock.Mock()
+
+        for conf in configs:
+            cfg = config.Config(conf, context, subnet, member_manager)
+
+            reserved_members = cfg.reserve_dns_members()
+
+            self.assertTrue(isinstance(reserved_members, list))
+
+    def test_reserve_members_list(self):
+        def mock_get_member(member_name):
+            return objects.Member(ip='10.20.30.40', name=member_name)
+
+        conf = {'condition': 'global'}
+        members = ['member40.com', 'member41.com']
+
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        member_manager = mock.Mock()
+        member_manager.get_member = mock_get_member
+        member_manager.find_members = mock.Mock(return_value=None)
+
+        cfg = config.Config(conf, context, subnet, member_manager)
+        cfg._dhcp_members = members
+        reserved_members = cfg.reserve_dhcp_members()
+
+        self.assertEqual(
+            reserved_members,
+            [
+                objects.Member(ip='10.20.30.40', name='member40.com'),
+                objects.Member(ip='10.20.30.40', name='member41.com')
+            ]
+        )
+
+    def test_subnet_update_not_allowed_if_subnet_name_is_in_pattern(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+        subnet_new = mock.Mock()
+        member_manager = mock.Mock()
+
+        cfg = {
+            'condition': 'global',
+            'hostname_pattern': 'host-{ip_address}',
+            'domain_suffix_pattern': '{subnet_name}.global.com'
+        }
+
+        conf = config.Config(cfg, context, subnet, member_manager)
+        self.assertRaises(exceptions.OperationNotAllowed,
+                          conf.verify_subnet_update_is_allowed, subnet_new)
+
+    def test_subnet_update_is_allowed_if_subnet_name_is_not_in_pattern(self):
+        context = mock.Mock()
+        subnet = mock.Mock()
+        subnet_new = mock.Mock()
+        member_manager = mock.Mock()
+
+        allowed_suffixes = [
+            'network_id',
+            'subnet_id',
+            'user_id',
+            'tenant_id',
+            'ip_address',
+            'network_name',
+            'instance_id'
+        ]
+
+        for allowed_suffix in allowed_suffixes:
+            domain_pattern = '{{0}}.global.com'.format(allowed_suffix)
+
+            cfg = {
+                'condition': 'global',
+                'hostname_pattern': 'host-{ip_address}',
+                'domain_suffix_pattern': domain_pattern
+            }
+
+            conf = config.Config(cfg, context, subnet, member_manager)
+            try:
+                conf.verify_subnet_update_is_allowed(subnet_new)
+            except exceptions.OperationNotAllowed as e:
+                self.fail('Unexpected exception {}'.format(e))
+
+    def test_same_configs_are_equal(self):
+        member_manager = mock.Mock()
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        cfg = {
+            'condition': 'global',
+            'network_view': 'netview',
+            'dns_view': 'dnsview',
+            'dhcp_members': ['m1', 'm2', 'm3'],
+            'dns_members': ['m1', 'm2', 'm3']
+        }
+
+        c1 = config.Config(cfg, context, subnet, member_manager)
+        c2 = config.Config(cfg, context, subnet, member_manager)
+
+        self.assertTrue(c1 == c1)
+        self.assertTrue(c1 == c2)
+        self.assertTrue(c2 == c1)
+        self.assertTrue(c2 == c2)
+        self.assertTrue(c1 != object())
+        self.assertTrue(c2 != object())
+
+    def test_same_configs_are_not_added_to_set(self):
+        member_manager = mock.Mock()
+        context = mock.Mock()
+        subnet = mock.Mock()
+
+        cfg = {
+            'condition': 'global',
+            'network_view': 'netview',
+            'dns_view': 'dnsview',
+            'dhcp_members': ['m1', 'm2', 'm3'],
+            'dns_members': ['m1', 'm2', 'm3']
+        }
+
+        s = set()
+
+        for _ in xrange(10):
+            s.add(config.Config(cfg, context, subnet, member_manager))
+
+        self.assertEqual(len(s), 1)
+
+        cfg['condition'] = 'tenant'
+        s.add(config.Config(cfg, context, subnet, member_manager))
+        self.assertEqual(len(s), 2)
+
+        s.add(config.Config(cfg, context, subnet, member_manager))
+        self.assertEqual(len(s), 2)
+
+
+class MemberManagerTestCase(base.BaseTestCase):
+    def test_raises_error_if_no_config_file(self):
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          config.MemberManager)
+
+    def test_returns_next_available_member(self):
+        context = mock.MagicMock()
+        member_config = [{"name": "member%d" % i,
+                          "member_name": "member%d" % i,
+                          "ipv4addr": "192.168.1.%d" % i,
+                          "ipv6addr": "2001:DB8::%s" % i}
+                         for i in xrange(1, 5)]
+
+        avail_members = []
+        for i in xrange(1, 5):
+            member = type('Member', (object,), {})
+            member.member_name = "member%d" % i
+            member.member_type = models.DHCP_MEMBER_TYPE
+            avail_members.append(member)
+
+        avail_member = avail_members[0]
+
+        mm = config.MemberManager(io.BytesIO(jsonutils.dumps(member_config)))
+
+        with mock.patch.object(infoblox_db, 'get_available_member',
+                               mock.Mock(return_value=avail_member)):
+            available_member = mm.next_available(context, models.DHCP_MEMBER_TYPE)
+            self.assertIn(available_member.ip,
+                          map(operator.itemgetter('ipv4addr'), member_config))
+
+    def test_raises_no_member_available_if_all_members_used(self):
+        context = mock.MagicMock()
+        member_config = [{"name": "member%d" % i,
+                          "ipv4addr": "192.168.1.%d" % i,
+                          "ipv6addr": "2001:DB8::%s" % i}
+                         for i in xrange(1, 5)]
+
+        used_members = [member_config[i]['name']
+                        for i in xrange(len(member_config))]
+
+        mm = config.MemberManager(io.BytesIO(jsonutils.dumps(member_config)))
+
+        with mock.patch.object(infoblox_db, 'get_used_members',
+                               mock.Mock(return_value=used_members)):
+            self.assertRaises(exceptions.InfobloxConfigException,
+                              mm.next_available,
+                              context,
+                              models.DHCP_MEMBER_TYPE)
+
+    def test_reserve_member_stores_member_in_db(self):
+        context = mock.Mock()
+        mapping = 'some-mapping-value'
+        member_name = 'member1'
+        member_config = [{"name": member_name,
+                          "ipv4addr": "192.168.1.1",
+                          "ipv6addr": "2001:DB8::1"}]
+
+        mm = config.MemberManager(io.BytesIO(jsonutils.dumps(member_config)))
+
+        with mock.patch.object(infoblox_db, 'attach_member') as attach_mock:
+            mm.reserve_member(context, mapping, member_name,
+                              models.DHCP_MEMBER_TYPE)
+
+            attach_mock.assert_called_once_with(
+                context, mapping, member_name, models.DHCP_MEMBER_TYPE)
+
+    def test_finds_member_for_mapping(self):
+        context = mock.Mock()
+        mapping = 'some-mapping-value'
+        expected_member_name = 'member1'
+        expected_ip = '10.0.0.1'
+        expected_ipv6 = '2001:DB8::3'
+        expected_map_id = None
+
+        expected_member = type('Member', (object,), {})
+        expected_member.member_name = expected_member_name
+        expected_member.map_id = expected_map_id
+        expected_member.member_type = models.DHCP_MEMBER_TYPE
+
+        expected_members = [expected_member]
+
+        mm = config.MemberManager(
+            io.BytesIO(jsonutils.dumps([{'name': expected_member_name,
+                                        'ipv4addr': expected_ip,
+                                        'ipv6addr': expected_ipv6,
+                                        'map_id': expected_map_id}])))
+
+        with mock.patch.object(infoblox_db, 'get_members') as get_mock:
+            get_mock.return_value = expected_members
+            members = mm.find_members(context, mapping,
+                                      models.DHCP_MEMBER_TYPE)
+
+            self.assertEqual(expected_ip, members[0].ip)
+            self.assertEqual(expected_members[0].member_name,
+                             members[0].name)
+
+    def test_builds_member_from_config(self):
+        ip = 'some-ip'
+        name = 'some-name'
+
+        mm = config.MemberManager(
+            io.BytesIO(jsonutils.dumps([{'name': name,
+                                        'ipv4addr': ip,
+                                        'ipv6addr': ip}])))
+
+        m = mm.get_member(name)
+
+        self.assertEqual(m.name, name)
+        self.assertEqual(m.ip, ip)
+
+    def test_raises_member_not_available_if_member_is_not_in_config(self):
+        ip = 'some-ip'
+        actual_name = 'some-name'
+        search_for_name = 'some-other-name'
+
+        mm = config.MemberManager(
+            io.BytesIO(jsonutils.dumps([{'name': actual_name,
+                                         'ipv4addr': ip,
+                                         'ipv6addr': ip}])))
+
+        self.assertRaises(exceptions.InfobloxConfigException, mm.get_member,
+                          search_for_name)
+
+    def test_member_marked_as_unavailable(self):
+        expected_ip = "192.168.1.2"
+        expected_ipv6 = "2001:DB8::3"
+        expected_name = "available_member"
+        member_config = [{"name": expected_name,
+                          "ipv4addr": expected_ip,
+                          "ipv6addr": expected_ipv6},
+                         {"name": "unavailable_member",
+                          "ipv4addr": "192.168.1.3",
+                          "ipv6addr": "2001:DB8::3",
+                          "is_available": False}]
+
+        expected_member = objects.Member(ip=expected_ip, name=expected_name)
+        mm = config.MemberManager(io.BytesIO(jsonutils.dumps(member_config)))
+
+        self.assertEqual(1, len(mm.configured_members))
+        self.assertEqual(expected_member, mm.configured_members[0])
+
+    def test_config_mismatch_tenant_id_value(self):
+        valid_config = """
+            [
+                {
+                    "condition": "tenant_id"
+                }
+            ]
+        """
+
+        self.assertRaises(
+            exceptions.InfobloxConfigException,
+            config.ConfigFinder,
+            stream=io.BytesIO(valid_config),
+            member_manager=mock.Mock()
+        )
+
+    def test_config_mismatch_subnet_range_value(self):
+        valid_config = """
+            [
+                {
+                    "condition": "subnet_range"
+                }
+            ]
+        """
+
+        self.assertRaises(
+            exceptions.InfobloxConfigException,
+            config.ConfigFinder,
+            stream=io.BytesIO(valid_config),
+            member_manager=mock.Mock()
+        )
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_connector.py b/neutron/tests/unit/ipam/drivers/infoblox/test_connector.py
new file mode 100755
index 0000000..e6e4dcf
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_connector.py
@@ -0,0 +1,266 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+import requests
+from requests import exceptions as req_exc
+
+from neutron.ipam.drivers.infoblox import connector
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.tests import base
+
+
+valid_config = mock.Mock()
+valid_config.infoblox_wapi = 'http://localhost'
+valid_config.infoblox_username = 'user'
+valid_config.infoblox_password = 'pass'
+valid_config.infoblox_sslverify = False
+valid_config.infoblox_http_max_retries = 3
+
+
+class UrlMatcher(object):
+    def __init__(self, url, obj):
+        self.url = url
+        self.obj = obj
+
+    def __eq__(self, actual_url):
+        return self.url in actual_url and self.obj in actual_url
+
+
+class TestInfobloxConnector(base.BaseTestCase):
+    def setUp(self):
+        super(TestInfobloxConnector, self).setUp()
+        self.config(infoblox_wapi='https://infoblox.example.org/wapi/v1.1/')
+        self.config(infoblox_username='admin')
+        self.config(infoblox_password='password')
+        self.connector = connector.Infoblox()
+
+    def test_throws_error_on_username_not_set(self):
+        fake_conf = mock.Mock()
+        fake_conf.infoblox_wapi = 'http://localhost'
+        fake_conf.infoblox_username = None
+        fake_conf.infoblox_password = 'password'
+
+        with mock.patch.object(connector.cfg, 'CONF', fake_conf):
+            self.assertRaises(exceptions.InfobloxIsMisconfigured,
+                              connector.Infoblox)
+
+    def test_throws_error_on_password_not_set(self):
+        fake_conf = mock.Mock()
+        fake_conf.infoblox_wapi = 'http://localhost'
+        fake_conf.infoblox_username = 'user'
+        fake_conf.infoblox_password = None
+
+        with mock.patch.object(connector.cfg, 'CONF', fake_conf):
+            self.assertRaises(exceptions.InfobloxIsMisconfigured,
+                              connector.Infoblox)
+
+    def test_throws_error_on_wapi_url_not_set(self):
+        fake_conf = mock.Mock()
+        fake_conf.infoblox_wapi = None
+        fake_conf.infoblox_username = 'user'
+        fake_conf.infoblox_password = 'pass'
+
+        with mock.patch.object(connector.cfg, 'CONF', fake_conf):
+            self.assertRaises(exceptions.InfobloxIsMisconfigured,
+                              connector.Infoblox)
+
+    @mock.patch.object(connector.cfg, 'CONF', valid_config)
+    def test_create_object(self):
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0'}
+
+        with mock.patch.object(requests.Session, 'post',
+                               return_value=mock.Mock()) as patched_create:
+            patched_create.return_value.status_code = 201
+            patched_create.return_value.content = '{}'
+            self.connector.create_object(objtype, payload)
+            patched_create.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v1.1/network',
+                data='{"ip": "0.0.0.0"}',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    def test_create_object_with_extattrs(self):
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0',
+                   'extattrs': {'Subnet ID': {'value': 'fake_subnet_id'}}}
+        with mock.patch.object(requests.Session, 'post',
+                               return_value=mock.Mock()) as patched_create:
+            patched_create.return_value.status_code = 201
+            patched_create.return_value.content = '{}'
+            self.connector.create_object(objtype, payload)
+            patched_create.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v1.1/network',
+                data='{"ip": "0.0.0.0", "extattrs": {"Subnet ID":'
+                     ' {"value": "fake_subnet_id"}}}',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    @mock.patch.object(connector.cfg, 'CONF', valid_config)
+    def test_get_object(self):
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0'}
+
+        with mock.patch.object(requests.Session, 'get',
+                               return_value=mock.Mock()) as patched_get:
+            patched_get.return_value.status_code = 200
+            patched_get.return_value.content = '{}'
+            self.connector.get_object(objtype, payload)
+            patched_get.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v1.1/network?ip=0.0.0.0',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    def test_get_object_in_cloud(self):
+        self.config(infoblox_wapi='https://infoblox.example.org/wapi/v2.0/')
+        self.connector = connector.Infoblox()
+
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0'}
+
+        with mock.patch.object(requests.Session, 'get',
+                               return_value=mock.Mock()) as patched_get:
+            patched_get.return_value.status_code = 200
+            patched_get.return_value.content = '{"network": "my-network"}'
+            self.connector.get_object(objtype, payload)
+            patched_get.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v2.0/network?'
+                'ip=0.0.0.0&_proxy_search=GM',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    def test_get_objects_with_extattrs_in_cloud(self):
+        self.config(infoblox_wapi='https://infoblox.example.org/wapi/v2.0/')
+        self.connector = connector.Infoblox()
+
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0'}
+        extattrs = {
+            'Subnet ID': {'value': 'fake_subnet_id'}
+        }
+        with mock.patch.object(requests.Session, 'get',
+                               return_value=mock.Mock()) as patched_get:
+            patched_get.return_value.status_code = 200
+            patched_get.return_value.content = '{"network": "my-network"}'
+            self.connector.get_object(objtype, payload, extattrs=extattrs)
+            patched_get.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v2.0/network?'
+                '*Subnet ID=fake_subnet_id&ip=0.0.0.0&_proxy_search=GM',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    def test_get_objects_with_extattrs(self):
+        objtype = 'network'
+        payload = {'ip': '0.0.0.0'}
+        extattrs = {
+            'Subnet ID': {'value': 'fake_subnet_id'}
+        }
+        with mock.patch.object(requests.Session, 'get',
+                               return_value=mock.Mock()) as patched_get:
+            patched_get.return_value.status_code = 200
+            patched_get.return_value.content = '{}'
+            self.connector.get_object(objtype, payload, extattrs=extattrs)
+            patched_get.assert_called_once_with(
+                'https://infoblox.example.org/wapi/'
+                'v1.1/network?*Subnet ID=fake_subnet_id&ip=0.0.0.0',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    @mock.patch.object(connector.cfg, 'CONF', valid_config)
+    def test_update_object(self):
+        ref = 'network'
+        payload = {'ip': '0.0.0.0'}
+
+        with mock.patch.object(requests.Session, 'put',
+                               return_value=mock.Mock()) as patched_update:
+            patched_update.return_value.status_code = 200
+            patched_update.return_value.content = '{}'
+            self.connector.update_object(ref, payload)
+            patched_update.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v1.1/network',
+                data='{"ip": "0.0.0.0"}',
+                headers={'Content-type': 'application/json'},
+                timeout=60,
+                verify=False
+            )
+
+    @mock.patch.object(connector.cfg, 'CONF', valid_config)
+    def test_delete_object(self):
+        ref = 'network'
+        with mock.patch.object(requests.Session, 'delete',
+                               return_value=mock.Mock()) as patched_delete:
+            patched_delete.return_value.status_code = 200
+            patched_delete.return_value.content = '{}'
+            self.connector.delete_object(ref)
+            patched_delete.assert_called_once_with(
+                'https://infoblox.example.org/wapi/v1.1/network',
+                timeout=60,
+                verify=False
+            )
+
+    def test_neutron_exception_is_raised_on_any_request_error(self):
+        # timeout exception raises InfobloxTimeoutError
+        f = mock.Mock()
+        f.__name__ = 'mock'
+        f.side_effect = req_exc.Timeout
+        self.assertRaises(exceptions.InfobloxTimeoutError,
+                          connector.reraise_neutron_exception(f))
+
+        # all other request exception raises InfobloxConnectionError
+        supported_exceptions = [req_exc.HTTPError,
+                                req_exc.ConnectionError,
+                                req_exc.ProxyError,
+                                req_exc.SSLError,
+                                req_exc.TooManyRedirects,
+                                req_exc.InvalidURL]
+
+        for exc in supported_exceptions:
+            f.side_effect = exc
+            self.assertRaises(exceptions.InfobloxConnectionError,
+                              connector.reraise_neutron_exception(f))
+
+    def test_non_cloud_api_detection(self):
+        wapi_not_cloud = ('https://infoblox.example.org/wapi/v1.4.1/',
+                          'https://infoblox.example.org/wapi/v1.9/',
+                          'https://wapi.wapi.wap/wapi/v1.99/')
+
+        for url in wapi_not_cloud:
+            print url
+            self.assertFalse(self.connector.is_cloud_wapi(url))
+
+    def test_cloud_api_detection(self):
+        wapi_cloud = ('https://infoblox.example.org/wapi/v2.1/',
+                      'https://infoblox.example.org/wapi/v2.0/',
+                      'https://wapi.wapi.wap/wapi/v2.0.1/',
+                      'https://wapi.wapi.wap/wapi/v3.0/',
+                      'https://wapi.wapi.wap/wapi/v11.0.1/')
+
+        for url in wapi_cloud:
+            self.assertTrue(self.connector.is_cloud_wapi(url))
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_dns_controller.py b/neutron/tests/unit/ipam/drivers/infoblox/test_dns_controller.py
new file mode 100755
index 0000000..2d3bcb6
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_dns_controller.py
@@ -0,0 +1,355 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+import taskflow.engines
+
+from neutron.common import constants as neutron_constants
+from neutron.db.infoblox import infoblox_db
+from neutron.ipam.drivers.infoblox import dns_controller
+from neutron.ipam.drivers.infoblox import infoblox_ipam
+from neutron.db.infoblox import infoblox_db
+from neutron.plugins.common import constants as plugins_constants
+from neutron.tests import base
+
+
+class SubstringMatcher(object):
+    def __init__(self, names):
+        if not isinstance(names, list):
+            names = [names]
+        self.names = names
+
+    def __eq__(self, expected):
+        return all([name in expected for name in self.names])
+
+
+class DnsControllerTestCase(base.BaseTestCase):
+    fip_netview_name = 'my-test-fip-netview-name'
+
+    def setUp(self):
+        super(DnsControllerTestCase, self).setUp()
+        self.manip = mock.Mock()
+        self.context = mock.Mock()
+        self.port = mock.MagicMock()
+        config_finder = mock.MagicMock()
+        expected_value = 'some-expected-value'
+
+        def port_dict(item):
+            if item == 'fixed_ips':
+                return [{'ip_address': 'some-ip',
+                         'subnet_id': 'some-id'}]
+
+            return expected_value
+        self.port.__getitem__.side_effect = port_dict
+
+        subnet = {'network_id': 'some-net-id',
+                  'name': 'some-dns'}
+
+        self.ip_allocator = mock.Mock()
+
+        self.dns_ctrlr = dns_controller.InfobloxDNSController(
+            self.ip_allocator, self.manip, config_finder=config_finder)
+        self.dns_ctrlr.ea_manager = mock.Mock()
+        self.dns_ctrlr.pattern_builder = mock.Mock()
+        self.dns_ctrlr._get_subnet = mock.Mock()
+        self.dns_ctrlr._get_subnet.return_value = subnet
+
+    def test_bind_host_names_binds_fqdn_with_ip_in_dns_view(self):
+        self.dns_ctrlr.bind_names(self.context, self.port)
+        assert self.ip_allocator.bind_names.called_once
+
+    def test_unbind_host_names_binds_fqdn_with_ip_in_dns_view(self):
+        self.dns_ctrlr.unbind_names(self.context, self.port)
+        assert self.ip_allocator.unbind_names.called_once
+
+    def test_restarts_services_on_bind(self):
+        self.dns_ctrlr.bind_names(self.context, self.port)
+        assert self.manip.restart_all_services.called_once
+
+    def test_restarts_services_on_unbind(self):
+        self.dns_ctrlr.unbind_names(self.context, self.port)
+        assert self.manip.restart_all_services.called_once
+
+    def test_get_hostname_pattern_dhcp_port(self):
+        port = {'device_owner': neutron_constants.DEVICE_OWNER_DHCP}
+        result = self.dns_ctrlr.get_hostname_pattern(port, mock.Mock())
+        self.assertEqual('dhcp-port-{ip_address}', result)
+
+    def test_get_hostname_pattern_router_iface(self):
+        port = {'device_owner': neutron_constants.DEVICE_OWNER_ROUTER_INTF}
+        result = self.dns_ctrlr.get_hostname_pattern(port, mock.Mock())
+        self.assertEqual('router-iface-{ip_address}', result)
+
+    def test_get_hostname_pattern_router_gw(self):
+        port = {'device_owner': neutron_constants.DEVICE_OWNER_ROUTER_GW}
+        result = self.dns_ctrlr.get_hostname_pattern(port, mock.Mock())
+        self.assertEqual('router-gw-{ip_address}', result)
+
+    def test_get_hostname_pattern_lb_vip(self):
+        port = {'device_owner': 'neutron:' + plugins_constants.LOADBALANCER}
+        result = self.dns_ctrlr.get_hostname_pattern(port, mock.Mock())
+        self.assertEqual('lb-vip-{ip_address}', result)
+
+    def test_get_hostname_pattern_instance_port(self):
+        port = {'device_owner': 'nova:compute'}
+        cfg_mock = mock.MagicMock()
+        cfg_mock.hostname_pattern = 'host-{ip_address}'
+
+        result = self.dns_ctrlr.get_hostname_pattern(port, cfg_mock)
+        self.assertEqual('host-{ip_address}', result)
+
+
+class GenericDNSControllerTestCase(base.BaseTestCase):
+    def test_fqdn_is_built_with_prefix_ip_address_and_dns_zone(self):
+        ip_address = '192.168.1.1'
+        prefix = 'host-'
+        zone = 'some.dns.zone'
+
+        fqdn = dns_controller.build_fqdn(prefix, zone, ip_address)
+
+        self.assertTrue(fqdn.startswith(prefix))
+        self.assertTrue(fqdn.endswith(zone))
+        self.assertIn(ip_address.replace('.', '-'), fqdn)
+
+    def test_no_exception_if_subnet_has_no_nameservers_defined(self):
+        subnet = {}
+        nss = dns_controller.get_nameservers(subnet)
+        self.assertTrue(nss == [])
+
+        subnet = {'dns_nameservers': object()}
+        nss = dns_controller.get_nameservers(subnet)
+        self.assertTrue(nss == [])
+
+        subnet = {'dns_nameservers': []}
+        nss = dns_controller.get_nameservers(subnet)
+        self.assertTrue(nss == [])
+
+
+class DomainZoneTestCase(base.BaseTestCase):
+    def test_two_dns_zones_created_on_create_dns_zone(self):
+        manip = mock.Mock()
+        context = infoblox_ipam.FlowContext(mock.Mock(), 'create-dns')
+        subnet = {'network_id': 'some-id',
+                  'name': 'some-name',
+                  'ip_version': 4,
+                  'cidr': '10.100.0.0/24'}
+        expected_member = 'member-name'
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.ns_group = None
+        cfg.reserve_dns_members.return_value = [expected_member]
+
+        config_finder.find_config_for_subnet.return_value = cfg
+
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+        dns_ctrlr.create_dns_zones(context, subnet)
+
+        taskflow.engines.run(context.parent_flow, store=context.store)
+
+        assert (manip.method_calls ==
+                [mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           expected_member,
+                                           mock.ANY,
+                                           zone_extattrs=mock.ANY),
+                 mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           expected_member,
+                                           mock.ANY,
+                                           prefix=mock.ANY,
+                                           zone_extattrs=mock.ANY,
+                                           zone_format=mock.ANY)])
+
+    def test_secondary_dns_members(self):
+        manip = mock.Mock()
+        context = infoblox_ipam.FlowContext(mock.Mock(), 'create-dns')
+        subnet = {'network_id': 'some-id',
+                  'name': 'some-name',
+                  'ip_version': 4,
+                  'cidr': '10.100.0.0/24'}
+        primary_dns_member = 'member-primary'
+        secondary_dns_members = ['member-secondary']
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.ns_group = None
+        cfg.reserve_dns_members.return_value = ([primary_dns_member]
+                                                + secondary_dns_members)
+
+        config_finder.find_config_for_subnet.return_value = cfg
+
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+        dns_ctrlr.create_dns_zones(context, subnet)
+
+        taskflow.engines.run(context.parent_flow, store=context.store)
+
+        assert (manip.method_calls ==
+                [mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           primary_dns_member,
+                                           secondary_dns_members,
+                                           zone_extattrs=mock.ANY),
+                 mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           primary_dns_member,
+                                           secondary_dns_members,
+                                           prefix=mock.ANY,
+                                           zone_extattrs=mock.ANY,
+                                           zone_format=mock.ANY)])
+
+    def test_prefix_for_classless_networks(self):
+        manip = mock.Mock()
+        context = infoblox_ipam.FlowContext(mock.Mock(), 'create-dns')
+        subnet = {'network_id': 'some-id',
+                  'name': 'some-name',
+                  'ip_version': 4,
+                  'cidr': '192.168.0.128/27'}
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.ns_group = None
+        cfg.reserve_dns_members.return_value = (['some-member'])
+
+        config_finder.find_config_for_subnet.return_value = cfg
+
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+        dns_ctrlr.create_dns_zones(context, subnet)
+
+        taskflow.engines.run(context.parent_flow, store=context.store)
+
+        assert (manip.method_calls ==
+                [mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           zone_extattrs=mock.ANY),
+                 mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           prefix=subnet['name'],
+                                           zone_extattrs=mock.ANY,
+                                           zone_format=mock.ANY)])
+
+    def test_prefix_for_classfull_networks(self):
+        manip = mock.Mock()
+        context = infoblox_ipam.FlowContext(mock.Mock(), 'create-dns')
+        subnet = {'network_id': 'some-id',
+                  'name': 'some-name',
+                  'ip_version': 4,
+                  'cidr': '192.168.0.0/24'}
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.ns_group = None
+        cfg.reserve_dns_members.return_value = (['some-member'])
+
+        config_finder.find_config_for_subnet.return_value = cfg
+
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+        dns_ctrlr.create_dns_zones(context, subnet)
+
+        taskflow.engines.run(context.parent_flow, store=context.store)
+
+        assert (manip.method_calls ==
+                [mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           zone_extattrs=mock.ANY),
+                 mock.call.create_dns_zone(mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           mock.ANY,
+                                           prefix=None,
+                                           zone_extattrs=mock.ANY,
+                                           zone_format=mock.ANY)
+                 ])
+
+    @mock.patch.object(infoblox_db, 'is_network_external',
+                       mock.Mock())
+    def test_two_dns_zones_deleted_when_not_using_global_dns_zone(self):
+        manip = mock.Mock()
+        context = mock.Mock()
+        subnet = {'network_id': 'some-id',
+                  'cidr': 'some-cidr',
+                  'name': 'some-name'}
+        expected_dns_view = 'some-expected-dns-view'
+
+        cfg = mock.Mock()
+        cfg.is_global_config = False
+        cfg.domain_suffix_pattern = '{subnet_name}.cloud.com'
+        cfg.dns_view = expected_dns_view
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+        config_finder.find_config_for_subnet.return_value = cfg
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+
+        network = {'id': 'some-net-id',
+                   'shared': False}
+        dns_ctrlr._get_network = mock.Mock()
+        dns_ctrlr._get_network.return_value = network
+        infoblox_db.is_network_external.return_value = False
+
+        dns_ctrlr.delete_dns_zones(context, subnet)
+
+        assert manip.method_calls == [
+            mock.call.delete_dns_zone(expected_dns_view, mock.ANY),
+            mock.call.delete_dns_zone(expected_dns_view, subnet['cidr'])
+        ]
+
+    def test_no_dns_zone_is_deleted_when_global_dns_zone_used(self):
+        manip = mock.Mock()
+        context = mock.Mock()
+        subnet = {'network_id': 'some-id',
+                  'cidr': 'some-cidr',
+                  'name': 'some-name'}
+        expected_dns_view = 'some-expected-dns-view'
+
+        cfg = mock.Mock()
+        cfg.is_global_config = True
+        cfg.domain_suffix_pattern = '{subnet_name}.cloud.com'
+        cfg.dns_view = expected_dns_view
+
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+        config_finder.find_config_for_subnet.return_value = cfg
+        dns_ctrlr = dns_controller.InfobloxDNSController(
+            ip_allocator, manip, config_finder)
+        dns_ctrlr.pattern_builder = mock.Mock()
+        dns_ctrlr.delete_dns_zones(context, subnet)
+
+        assert not manip.delete_dns_zone.called
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_ip_allocator.py b/neutron/tests/unit/ipam/drivers/infoblox/test_ip_allocator.py
new file mode 100755
index 0000000..2748c0b
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_ip_allocator.py
@@ -0,0 +1,115 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+from neutron.ipam.drivers.infoblox import ip_allocator
+from neutron.tests import base
+
+
+class FixedAddressAllocatorTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(FixedAddressAllocatorTestCase, self).setUp()
+        self.ib_mock = mock.Mock()
+
+        self.extattrs = 'test-extattrs'
+        self.netview = 'some-test-net-view'
+        self.mac = 'de:ad:be:ef:00:00'
+        self.ip = '192.168.1.1'
+        self.dnsview = 'some-dns-view'
+        self.zone_auth = 'zone-auth'
+        self.hostname = 'host1'
+        self.dhcp_enabled = True
+
+        self.allocator = ip_allocator.FixedAddressIPAllocator(self.ib_mock)
+
+    def test_creates_fixed_address_on_allocate_ip(self):
+        self.allocator.allocate_given_ip(
+            self.netview, self.dnsview, self.zone_auth,
+            self.hostname, self.mac, self.ip, self.extattrs)
+
+        self.ib_mock.create_fixed_address_for_given_ip.assert_called_once_with(
+            self.netview, self.mac, self.ip, self.extattrs)
+
+    def test_creates_fixed_address_range_on_range_allocation(self):
+        first_ip = '192.168.1.1'
+        last_ip = '192.168.1.123'
+
+        self.allocator.allocate_ip_from_range(
+            self.dnsview, self.netview, self.zone_auth, self.hostname,
+            self.mac, first_ip, last_ip, self.extattrs)
+
+        self.ib_mock.create_fixed_address_from_range.assert_called_once_with(
+            self.netview, self.mac, first_ip, last_ip, self.extattrs)
+
+    def test_deletes_fixed_address(self):
+        self.allocator.deallocate_ip(self.netview, self.dnsview, self.ip)
+
+        self.ib_mock.delete_fixed_address.assert_called_once_with(self.netview,
+                                                                  self.ip)
+
+
+class HostRecordAllocatorTestCase(base.BaseTestCase):
+    def test_creates_host_record_on_allocate_ip(self):
+        ib_mock = mock.MagicMock()
+
+        netview = 'some-test-net-view'
+        dnsview = 'some-dns-view'
+        zone_auth = 'zone-auth'
+        hostname = 'host1'
+        mac = 'de:ad:be:ef:00:00'
+        ip = '192.168.1.1'
+
+        ib_mock.find_hostname.return_value = None
+
+        allocator = ip_allocator.HostRecordIPAllocator(ib_mock)
+        allocator.allocate_given_ip(netview, dnsview, zone_auth, hostname,
+                                    mac, ip)
+
+        ib_mock.create_host_record_for_given_ip.assert_called_once_with(
+            dnsview, zone_auth, hostname, mac, ip, mock.ANY)
+
+    def test_creates_host_record_range_on_range_allocation(self):
+        ib_mock = mock.MagicMock()
+
+        netview = 'some-test-net-view'
+        dnsview = 'some-dns-view'
+        zone_auth = 'zone-auth'
+        hostname = 'host1'
+        mac = 'de:ad:be:ef:00:00'
+        first_ip = '192.168.1.2'
+        last_ip = '192.168.1.254'
+
+        ib_mock.find_hostname.return_value = None
+
+        allocator = ip_allocator.HostRecordIPAllocator(ib_mock)
+        allocator.allocate_ip_from_range(
+            dnsview, netview, zone_auth, hostname, mac, first_ip, last_ip)
+
+        ib_mock.create_host_record_from_range.assert_called_once_with(
+            dnsview, netview, zone_auth, hostname,
+            mac, first_ip, last_ip, mock.ANY)
+
+    def test_deletes_host_record(self):
+        ib_mock = mock.MagicMock()
+
+        netview = 'some-test-net-view'
+        dnsview = 'some-dns-view'
+        ip = '192.168.1.2'
+
+        allocator = ip_allocator.HostRecordIPAllocator(ib_mock)
+        allocator.deallocate_ip(netview, dnsview, ip)
+
+        ib_mock.delete_host_record.assert_called_once_with(dnsview, ip)
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_ipam_controller.py b/neutron/tests/unit/ipam/drivers/infoblox/test_ipam_controller.py
new file mode 100755
index 0000000..2695722
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_ipam_controller.py
@@ -0,0 +1,837 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+import taskflow.engines
+
+from neutron.common import exceptions as neutron_exc
+from neutron.db.infoblox import infoblox_db as infoblox_db
+from neutron.ipam.drivers.infoblox import ea_manager
+from neutron.ipam.drivers.infoblox import exceptions as ib_exceptions
+from neutron.ipam.drivers.infoblox import infoblox_ipam
+from neutron.ipam.drivers.infoblox import ipam_controller
+from neutron.ipam.drivers.infoblox import objects
+from neutron.tests import base
+
+
+class SubstringMatcher(object):
+    def __init__(self, expected):
+        self.expected = expected
+
+    def __eq__(self, actual):
+        return self.expected in actual
+
+    def __repr__(self):
+        return "Expected substring: '{}'".format(self.expected)
+
+
+class CreateSubnetTestCases(base.BaseTestCase):
+    def setUp(self):
+        super(CreateSubnetTestCases, self).setUp()
+
+        self.expected_net_view_name = 'some-tenant-id'
+        self.cidr = 'some-cidr'
+        self.first_ip = '192.168.0.1'
+        self.last_ip = '192.168.0.254'
+        self.subnet = mock.MagicMock()
+        self.subnet.__getitem__.side_effect = mock.MagicMock()
+        self.object_manipulator = mock.Mock()
+        ip_allocator = mock.Mock()
+        self.object_manipulator.network_exists.return_value = False
+        self.object_manipulator.set_network_view = mock.MagicMock()
+
+        cfg = mock.Mock()
+        cfg.reserve_dhcp_members = mock.Mock(return_value=[])
+        cfg.reserve_dns_members = mock.Mock(return_value=[])
+        cfg.dhcp_members = ['member1.com']
+        cfg.dns_members = ['member1.com']
+
+        config_finder = mock.Mock()
+        config_finder.find_config_for_subnet = mock.Mock(return_value=cfg)
+
+        context = infoblox_ipam.FlowContext(mock.MagicMock(), 'create-subnet')
+
+        b = ipam_controller.InfobloxIPAMController(self.object_manipulator,
+                                                   config_finder,
+                                                   ip_allocator)
+        b.ea_manager = mock.Mock()
+        b.create_subnet(context, self.subnet)
+        taskflow.engines.run(context.parent_flow, store=context.store)
+
+    def test_network_view_is_created_on_subnet_creation(self):
+        assert self.object_manipulator.create_network_view.called_once
+
+    def test_dns_view_is_created_on_subnet_creation(self):
+        assert self.object_manipulator.create_dns_view.called_once
+
+    def test_infoblox_network_is_created_on_subnet_create(self):
+        assert self.object_manipulator.create_network.called_once
+
+    def test_ip_range_is_created_on_subnet_create(self):
+        assert self.object_manipulator.create_ip_range.called_once
+
+
+class UpdateSubnetTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(UpdateSubnetTestCase, self).setUp()
+        self.object_manipulator = mock.Mock()
+        self.context = mock.Mock()
+        ip_allocator = mock.Mock()
+        config_finder = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.dhcp_members = ['member1.com']
+        cfg.dns_members = ['member1.com']
+        config_finder.find_config_for_subnet.return_value = cfg
+
+        self.ipam = ipam_controller.InfobloxIPAMController(
+            self.object_manipulator, config_finder, ip_allocator)
+        self.ipam.ea_manager = mock.Mock()
+
+        self.sub_id = 'fake-id'
+        self.new_nameservers = ['new_serv1', 'new_serv2']
+        self.sub = dict(
+            id=self.sub_id,
+            cidr='test-cidr',
+            dns_nameservers=self.new_nameservers,
+            network_id='some-net-id'
+        )
+        self.ib_net = objects.Network()
+        self.object_manipulator.get_network.return_value = self.ib_net
+
+    @mock.patch.object(infoblox_db, 'get_subnet_dhcp_port_address',
+                       mock.Mock(return_value=None))
+    def test_update_subnet_dns_no_primary_ip(self):
+        self.ipam.update_subnet(self.context, self.sub_id, self.sub)
+
+        self.assertEqual(self.new_nameservers, self.ib_net.dns_nameservers)
+        self.object_manipulator.update_network_options.assert_called_once_with(
+            self.ib_net, mock.ANY
+        )
+
+    @mock.patch.object(infoblox_db, 'get_subnet_dhcp_port_address',
+                       mock.Mock(return_value=None))
+    def test_update_subnet_dns_primary_is_member_ip(self):
+        self.ib_net.member_ip_addrs = ['member-ip']
+        self.ib_net.dns_nameservers = ['member-ip', 'old_serv1', 'old_serv']
+
+        self.ipam.update_subnet(self.context, self.sub_id, self.sub)
+
+        self.assertEqual(['member-ip'] + self.new_nameservers,
+                         self.ib_net.dns_nameservers)
+        self.object_manipulator.update_network_options.assert_called_once_with(
+            self.ib_net, mock.ANY
+        )
+
+    @mock.patch.object(infoblox_db, 'get_subnet_dhcp_port_address',
+                       mock.Mock())
+    def test_update_subnet_dns_primary_is_relay_ip(self):
+        self.ib_net.member_ip_addr = 'fake_ip'
+        self.ib_net.dns_nameservers = ['relay_ip', '1.1.1.1', '2.2.2.2']
+
+        infoblox_db.get_subnet_dhcp_port_address.return_value = 'relay-ip'
+
+        self.ipam.update_subnet(self.context, self.sub_id, self.sub)
+
+        self.assertEqual(['relay-ip'] + self.new_nameservers,
+                         self.ib_net.dns_nameservers)
+        self.object_manipulator.update_network_options.assert_called_once_with(
+            self.ib_net, mock.ANY
+        )
+
+    def test_extensible_attributes_get_updated(self):
+        ea_manager = mock.Mock()
+        manip = mock.MagicMock()
+        config_finder = mock.Mock()
+        config = mock.Mock()
+        config.dhcp_members = ['member1.com']
+        config.dns_members = ['member1.com']
+        config_finder.find_config_for_subnet = mock.Mock(return_value=config)
+        context = mock.Mock()
+        subnet_id = 'some-id'
+        subnet = mock.MagicMock()
+        subnet.name = None
+
+        ctrlr = ipam_controller.InfobloxIPAMController(
+            manip, config_finder, extattr_manager=ea_manager)
+
+        ctrlr.update_subnet(context, subnet_id, subnet)
+
+        assert manip.update_network_options.called_once
+
+
+class AllocateIPTestCase(base.BaseTestCase):
+    def test_host_record_created_on_allocate_ip(self):
+        infoblox = mock.Mock()
+        member_config = mock.MagicMock()
+        ip_allocator = mock.Mock()
+        context = mock.Mock()
+
+        subnet = {'tenant_id': 'some-id', 'id': 'some-id'}
+        mac = 'aa:bb:cc:dd:ee:ff'
+        port = {'id': 'port_id',
+                'mac_address': mac}
+        ip_dict = {'ip_address': '192.168.1.1',
+                   'subnet_id': 'fake-id'}
+        ip = {'ip_address': '192.168.1.1'}
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b.pattern_builder = mock.Mock()
+        b.ea_manager = mock.Mock()
+
+        b.allocate_ip(context, subnet, port, ip_dict)
+
+        ip_allocator.allocate_given_ip.assert_called_once_with(
+            mock.ANY, mock.ANY, mock.ANY, mock.ANY, mac, ip['ip_address'],
+            mock.ANY)
+
+    def test_host_record_from_range_created_on_allocate_ip(self):
+        infoblox = mock.Mock()
+        member_config = mock.MagicMock()
+        ip_allocator = mock.Mock()
+        context = mock.Mock()
+
+        first_ip = '192.168.1.1'
+        last_ip = '192.168.1.132'
+
+        subnet = {'allocation_pools': [{'first_ip': first_ip,
+                                        'last_ip': last_ip}],
+                  'tenant_id': 'some-id',
+                  'id': 'some-id'}
+
+        mac = 'aa:bb:cc:dd:ee:ff'
+        port = {'mac_address': mac,
+                'device_owner': 'owner'}
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b.pattern_builder = mock.Mock()
+        b.ea_manager = mock.Mock()
+        b.allocate_ip(context, subnet, port)
+
+        assert not ip_allocator.allocate_given_ip.called
+        ip_allocator.allocate_ip_from_range.assert_called_once_with(
+            mock.ANY, mock.ANY, mock.ANY, mock.ANY, mac, first_ip, last_ip,
+            mock.ANY)
+
+    def test_cannot_allocate_ip_raised_if_empty_range(self):
+        infoblox = mock.Mock()
+        member_config = mock.Mock()
+        context = mock.Mock()
+        ip_allocator = mock.Mock()
+
+        hostname = 'hostname'
+        subnet = {'allocation_pools': [],
+                  'tenant_id': 'some-id',
+                  'cidr': '192.168.0.0/24'}
+        mac = 'aa:bb:cc:dd:ee:ff'
+        host = {'name': hostname,
+                'mac_address': mac,
+                'device_owner': 'owner'}
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b.pattern_builder = mock.Mock()
+        b.ea_manager = mock.Mock()
+
+        assert not infoblox.create_host_record_range.called
+        assert not infoblox.create_host_record_ip.called
+
+        ip = b.allocate_ip(context, subnet, host)
+        self.assertIsNone(ip)
+
+
+class DeallocateIPTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(DeallocateIPTestCase, self).setUp()
+
+        self.infoblox = mock.Mock()
+
+        cfg = mock.Mock()
+        cfg.dhcp_members = ['172.25.1.1']
+
+        config_finder = mock.MagicMock()
+        config_finder.find_config_for_subnet = mock.Mock(return_value=cfg)
+
+        context = mock.MagicMock()
+        self.ip_allocator = mock.Mock()
+
+        hostname = 'hostname'
+        self.ip = '192.168.0.1'
+        subnet = {'tenant_id': 'some-id',
+                  'network_id': 'some-id',
+                  'id': 'some-id'}
+        mac = 'aa:bb:cc:dd:ee:ff'
+        host = {'name': hostname,
+                'mac_address': mac}
+
+        b = ipam_controller.InfobloxIPAMController(self.infoblox,
+                                                   config_finder,
+                                                   self.ip_allocator)
+        b.deallocate_ip(context, subnet, host, self.ip)
+
+    def test_ip_is_deallocated(self):
+        self.ip_allocator.deallocate_ip.assert_called_once_with(
+            mock.ANY, mock.ANY, self.ip)
+
+    def test_dns_and_dhcp_services_restarted(self):
+        assert self.infoblox.restart_all_services.called_once
+
+
+class NetOptionsMatcher(object):
+    def __init__(self, expected_ip):
+        self.expected_ip = expected_ip
+
+    def __eq__(self, actual_net):
+        return self.expected_ip in actual_net.dns_nameservers
+
+    def __repr__(self):
+        return "{}".format(self.expected_ip)
+
+
+class DnsNameserversTestCase(base.BaseTestCase):
+    def test_network_is_updated_with_new_ip(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_config = mock.Mock()
+        context = mock.MagicMock()
+
+        expected_ip = '192.168.1.1'
+        cidr = '192.168.1.0/24'
+        port = {'fixed_ips': [{'subnet_id': 'some-id',
+                               'ip_address': expected_ip}]}
+        subnet = {'cidr': cidr,
+                  'tenant_id': 'some-id'}
+
+        network = objects.Network()
+        network.members = ['member1']
+        network.member_ip_addrs = ['192.168.1.2']
+        network.dns_nameservers = [expected_ip]
+
+        infoblox.get_network.return_value = network
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b._get_subnet = mock.Mock()
+        b._get_subnet.return_value = subnet
+
+        b.set_dns_nameservers(context, port)
+
+        matcher = NetOptionsMatcher(expected_ip)
+        infoblox.update_network_options.assert_called_once_with(matcher)
+
+    def test_network_is_not_updated_if_network_has_no_members(self):
+        infoblox = mock.Mock()
+        member_config = mock.Mock()
+        ip_allocator = mock.Mock()
+        context = mock.MagicMock()
+
+        expected_ip = '192.168.1.1'
+        cidr = '192.168.1.0/24'
+        port = {'fixed_ips': [{'subnet_id': 'some-id',
+                               'ip_address': expected_ip}]}
+        subnet = {'cidr': cidr,
+                  'tenant_id': 'some-id'}
+
+        infoblox.get_network.return_value = objects.Network()
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b._get_subnet = mock.Mock()
+        b._get_subnet.return_value = subnet
+
+        b.set_dns_nameservers(context, port)
+
+        assert not infoblox.update_network_options.called
+
+    def test_network_is_not_updated_if_network_has_no_dns_members(self):
+        infoblox = mock.Mock()
+        member_config = mock.Mock()
+        ip_allocator = mock.Mock()
+        context = mock.MagicMock()
+
+        expected_ip = '192.168.1.1'
+        cidr = '192.168.1.0/24'
+        port = {'fixed_ips': [{'subnet_id': 'some-id',
+                               'ip_address': expected_ip}]}
+        subnet = {'cidr': cidr,
+                  'tenant_id': 'some-id'}
+        network = objects.Network()
+        network.members = ['member1']
+
+        infoblox.get_network.return_value = network
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_config,
+                                                   ip_allocator)
+        b._get_subnet = mock.Mock()
+        b._get_subnet.return_value = subnet
+
+        b.set_dns_nameservers(context, port)
+
+        assert not infoblox.update_network_options.called
+
+
+class DeleteSubnetTestCase(base.BaseTestCase):
+    @mock.patch.object(infoblox_db, 'is_network_external',
+                       mock.Mock())
+    def test_ib_network_deleted(self):
+        infoblox = mock.Mock()
+        member_conf = mock.Mock()
+        config = mock.Mock()
+        config.dhcp_members = ['member1.com']
+        config.dns_members = ['member1.com']
+        config.is_global_config = False
+        member_conf.find_config_for_subnet = mock.Mock(return_value=config)
+        ip_allocator = mock.Mock()
+        context = mock.MagicMock()
+
+        cidr = '192.168.0.0/24'
+        subnet = mock.MagicMock()
+        subnet.__getitem__ = mock.Mock(return_value=cidr)
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator)
+        b._get_network = mock.Mock()
+        b._get_network.return_value = {
+            'network_id': 'some-net-id',
+            'shared': False
+        }
+        infoblox_db.is_network_external.return_value = False
+
+        b.delete_subnet(context, subnet)
+
+        infoblox.delete_network.assert_called_once_with(mock.ANY, cidr=cidr)
+
+    def test_member_released(self):
+        infoblox = mock.Mock()
+        member_finder = mock.Mock()
+        config = mock.Mock()
+        config.dhcp_members = ['member1.com']
+        config.dns_members = ['member1.com']
+        member_finder.find_config_for_subnet = mock.Mock(return_value=config)
+        ip_allocator = mock.Mock()
+        context = mock.MagicMock()
+
+        subnet = mock.MagicMock()
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_finder,
+                                                   ip_allocator)
+        b.delete_subnet(context, subnet)
+
+        assert member_finder.member_manager.release_member.called_once
+
+    def test_preconfigured_dns_view_gets_deleted(self):
+        dns_view = "fake dns view"
+        infoblox = mock.Mock()
+        infoblox.has_dns_zones = mock.Mock(return_value=False)
+        ip_allocator = mock.Mock()
+        config = mock.Mock()
+        config.dhcp_members = ['member1.com']
+        config.dns_members = ['member1.com']
+        config._dns_view = dns_view
+        config_finder = mock.Mock()
+        config_finder.find_config_for_subnet = mock.Mock(return_value=config)
+        context = mock.Mock()
+        subnet = mock.MagicMock()
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   config_finder,
+                                                   ip_allocator)
+
+        b.get_subnets_by_network = mock.MagicMock()
+        b.delete_subnet(context, subnet)
+
+        infoblox.delete_dns_view.assert_called_once_with(dns_view)
+
+    def test_network_view_deleted(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        config = mock.Mock()
+        config.dhcp_members = ['member1.com']
+        config.dns_members = ['member1.com']
+        member_conf.find_config_for_subnet = mock.Mock(return_value=config)
+        context = mock.Mock()
+        network = mock.MagicMock()
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator)
+
+        b.get_subnets_by_network = mock.MagicMock()
+        b.delete_subnet(context, network)
+
+        assert infoblox.delete_network_view.called_once
+
+
+class CreateSubnetFlowTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(CreateSubnetFlowTestCase, self).setUp()
+
+        self.infoblox = mock.Mock()
+        member_conf = mock.MagicMock()
+        ip_allocator = mock.Mock()
+        self.expected_exception = Exception
+        self.context = infoblox_ipam.FlowContext(mock.MagicMock(),
+                                                 'create-subnet')
+        self.subnet = {'cidr': '192.168.0.0/24',
+                       'tenant_id': 'some-id',
+                       'network_id': 'some-id',
+                       'gateway_ip': '192.168.1.1',
+                       'allocation_pools': [{'start': 'start',
+                                             'end': 'end'}],
+                       'ip_version': 'ipv4',
+                       'name': 'some-name',
+                       'enable_dhcp': True}
+
+        self.infoblox.create_ip_range.side_effect = Exception()
+        self.infoblox.network_exists.return_value = False
+
+        self.b = ipam_controller.InfobloxIPAMController(self.infoblox,
+                                                        member_conf,
+                                                        ip_allocator)
+        self.b.pattern_builder = mock.Mock()
+        self.b.ea_manager = mock.Mock()
+
+    def test_flow_is_reverted_in_case_of_error(self):
+        self.infoblox.has_networks.return_value = False
+        self.b.create_subnet(self.context, self.subnet)
+        self.assertRaises(self.expected_exception, taskflow.engines.run,
+                          self.context.parent_flow, store=self.context.store)
+
+        assert self.infoblox.delete_network.called
+        assert not self.infoblox.delete_dns_view.called
+        assert self.infoblox.delete_network_view.called
+
+    def test_network_view_is_not_deleted_if_has_networks(self):
+        self.infoblox.has_networks.return_value = True
+        self.b.create_subnet(self.context, self.subnet)
+
+        self.assertRaises(self.expected_exception, taskflow.engines.run,
+                          self.context.parent_flow, store=self.context.store)
+
+        assert self.infoblox.delete_network.called
+        assert not self.infoblox.delete_dns_view.called
+        assert not self.infoblox.delete_network_view.called
+
+
+class CreateSubnetFlowNiosNetExistsTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(CreateSubnetFlowNiosNetExistsTestCase, self).setUp()
+
+        self.infoblox = mock.Mock()
+        member_conf = mock.MagicMock()
+        ip_allocator = mock.Mock()
+        self.context = infoblox_ipam.FlowContext(mock.MagicMock(),
+                                                 'create-subnet')
+        self.subnet = mock.MagicMock()
+        self.subnet.__getitem__.side_effect = mock.MagicMock()
+
+        self.infoblox.network_exists.return_value = True
+
+        self.b = ipam_controller.InfobloxIPAMController(self.infoblox,
+                                                        member_conf,
+                                                        ip_allocator)
+
+    def test_nios_network_is_updated_for_shared_os_network(self):
+        self.b.ea_manager.get_extattrs_for_network = mock.Mock(
+            return_value={
+                'Is External': {
+                    'value': 'False'},
+                'Is Shared': {
+                    'value': 'True'}
+            })
+
+        self.b.create_subnet(self.context, self.subnet)
+
+        taskflow.engines.run(self.context.parent_flow,
+                             store=self.context.store)
+        assert self.infoblox.update_network_options.called_once
+
+    def test_nios_network_is_updated_for_shared_external_os_network(self):
+        self.b.ea_manager.get_extattrs_for_network = mock.Mock(
+            return_value={
+                'Is External': {
+                    'value': 'True'},
+                'Is Shared': {
+                    'value': 'True'}
+            })
+
+        self.b.create_subnet(self.context, self.subnet)
+
+        taskflow.engines.run(self.context.parent_flow,
+                             store=self.context.store)
+        assert self.infoblox.update_network_options.called_once
+
+    def test_nios_network_is_updated_for_external_os_network(self):
+        self.b.ea_manager.get_extattrs_for_network = mock.Mock(
+            return_value={
+                'Is External': {
+                    'value': 'True'},
+                'Is Shared': {
+                    'value': 'False'}
+            })
+
+        self.b.create_subnet(self.context, self.subnet)
+
+        taskflow.engines.run(self.context.parent_flow,
+                             store=self.context.store)
+        assert self.infoblox.update_network_options.called_once
+
+    def test_exception_is_raised_if_network_is_private(self):
+        self.b.ea_manager.get_extattrs_for_network = mock.Mock(
+            return_value={
+                'Is External': {
+                    'value': 'False'},
+                'Is Shared': {
+                    'value': 'False'}
+            })
+
+        self.b.create_subnet(self.context, self.subnet)
+
+        self.assertRaises(
+            ib_exceptions.InfobloxInternalPrivateSubnetAlreadyExist,
+            taskflow.engines.run,
+            self.context.parent_flow,
+            store=self.context.store
+        )
+
+
+class DeleteNetworkTestCase(base.BaseTestCase):
+    def test_deletes_all_subnets(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        context = mock.Mock()
+        db_manager = mock.Mock()
+        network = {'id': 'some-id'}
+        num_subnets = 5
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator,
+                                                   db_mgr=db_manager)
+
+        b.delete_subnet = mock.Mock()
+        db_manager.get_subnets_by_network = mock.Mock()
+        db_manager.get_subnets_by_network.return_value = [
+            mock.Mock() for _ in xrange(num_subnets)]
+
+        b.delete_network(context, network)
+
+        assert b.delete_subnet.called
+        assert b.delete_subnet.call_count == num_subnets
+
+    def test_deletes_network_view(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        context = mock.MagicMock()
+        network_id = 'some-id'
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator)
+
+        b.delete_network(context, network_id)
+
+        assert infoblox.delete_network_view.called_once
+
+    def test_deletes_management_ip(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        context = mock.Mock()
+        network = mock.MagicMock()
+        ib_db = mock.Mock()
+        ea_manager = mock.Mock()
+        db_manager = mock.Mock()
+
+        ib_db.is_network_external.return_value = False
+
+        net_view_name = 'expected_network_view'
+        cidr = 'expected_cidr'
+
+        self.config(dhcp_relay_management_network_view=net_view_name,
+                    dhcp_relay_management_network=cidr)
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator,
+                                                   ea_manager,
+                                                   ib_db,
+                                                   db_mgr=db_manager)
+
+        b.delete_subnet = mock.Mock()
+        db_manager.get_subnets_by_network = mock.MagicMock()
+
+        b.delete_network(context, network)
+        infoblox.delete_object_by_ref.assert_called_once_with(mock.ANY)
+
+    def test_deletes_management_ip_from_db(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        context = mock.Mock()
+        expected_net_id = 'some-net-id'
+        ib_db = mock.Mock()
+        db_manager = mock.Mock()
+
+        ib_db.is_network_external.return_value = False
+        net_view_name = 'expected_network_view'
+        cidr = 'expected_cidr'
+
+        self.config(dhcp_relay_management_network_view=net_view_name,
+                    dhcp_relay_management_network=cidr)
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator,
+                                                   ib_db=ib_db,
+                                                   db_mgr=db_manager)
+
+        b.delete_subnet = mock.Mock()
+        db_manager.get_subnets_by_network = mock.MagicMock()
+
+        b.delete_network(context, expected_net_id)
+        ib_db.delete_management_ip.assert_called_once_with(
+            context, expected_net_id)
+
+    def test_does_not_delete_management_network_ip_for_external_net(self):
+        infoblox = mock.Mock()
+        ip_allocator = mock.Mock()
+        member_conf = mock.Mock()
+        context = mock.MagicMock()
+        network_id = mock.MagicMock()
+        ib_db = mock.Mock()
+        ea_manager = mock.Mock()
+
+        ib_db.is_network_external.return_value = True
+
+        net_view_name = 'expected_network_view'
+        cidr = 'expected_cidr'
+
+        self.config(dhcp_relay_management_network_view=net_view_name,
+                    dhcp_relay_management_network=cidr)
+
+        b = ipam_controller.InfobloxIPAMController(infoblox,
+                                                   member_conf,
+                                                   ip_allocator,
+                                                   ea_manager,
+                                                   ib_db)
+        b.delete_network(context, network_id)
+
+        assert infoblox.delete_object_by_ref.called
+        assert ib_db.delete_management_ip.called
+
+
+class CreateNetworkTestCase(base.BaseTestCase):
+    def test_creates_fixed_address_object_in_management_network(self):
+        infoblox = mock.Mock()
+        config_finder = mock.Mock()
+        ip_allocator = mock.Mock()
+        ea_manager = mock.Mock()
+        context = mock.Mock()
+        network = mock.MagicMock()
+        network.get.return_value = False
+        network.__getitem__.side_effect = mock.Mock()
+
+        expected_net_view = 'expected_net_view_name'
+        cidr = '1.0.0.0/24'
+        expected_mac = '00:00:00:00:00:00'
+        self.config(dhcp_relay_management_network_view=expected_net_view,
+                    dhcp_relay_management_network=cidr)
+
+        c = ipam_controller.InfobloxIPAMController(infoblox, config_finder,
+                                                   ip_allocator, ea_manager)
+
+        c.create_network(context, network)
+        infoblox.create_fixed_address_from_cidr.assert_called_once_with(
+            expected_net_view, expected_mac, cidr, mock.ANY)
+
+    def test_stores_fixed_address_object_in_db(self):
+        infoblox = mock.Mock()
+        config_finder = mock.Mock()
+        ip_allocator = mock.Mock()
+        ea_manager = mock.Mock()
+        context = mock.Mock()
+        ib_db = mock.Mock()
+        expected_net_id = 'some-net-id'
+
+        network = mock.MagicMock()
+        network.get.return_value = False
+        network.__getitem__.side_effect = \
+            lambda key: expected_net_id if key == 'id' else None
+
+        expected_net_view = 'expected_net_view_name'
+        cidr = '1.0.0.0/24'
+        self.config(dhcp_relay_management_network_view=expected_net_view,
+                    dhcp_relay_management_network=cidr)
+
+        c = ipam_controller.InfobloxIPAMController(
+            infoblox, config_finder, ip_allocator, ea_manager, ib_db)
+
+        c.create_network(context, network)
+
+        ib_db.add_management_ip.assert_called_once_with(
+            context, expected_net_id, mock.ANY)
+
+    def test_does_nothing_if_mgmt_net_is_not_set_in_config(self):
+        infoblox = mock.Mock()
+        config_finder = mock.Mock()
+        ip_allocator = mock.Mock()
+        ea_manager = mock.Mock()
+        context = mock.Mock()
+        ib_db = mock.Mock()
+        network = mock.Mock()
+        network.get.return_value = False
+
+        c = ipam_controller.InfobloxIPAMController(
+            infoblox, config_finder, ip_allocator, ea_manager, ib_db)
+
+        c.create_network(context, network)
+
+        assert not infoblox.create_fixed_address_from_cidr.called
+        assert not ib_db.add_management_ip.called
+
+    def test_does_nothing_for_external_net(self):
+        infoblox = mock.Mock()
+        config_finder = mock.Mock()
+        ip_allocator = mock.Mock()
+        ea_manager = mock.Mock()
+        context = mock.Mock()
+        ib_db = mock.Mock()
+        network = mock.Mock()
+
+        c = ipam_controller.InfobloxIPAMController(
+            infoblox, config_finder, ip_allocator, ea_manager, ib_db)
+
+        try:
+            c.create_network(context, network)
+        except neutron_exc.InvalidConfigurationOption as e:
+            self.fail('Unexpected exception: {}'.format(e))
+
+        assert not infoblox.create_fixed_address_from_cidr.called
+        assert not ib_db.add_management_ip.called
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_object_manipulator.py b/neutron/tests/unit/ipam/drivers/infoblox/test_object_manipulator.py
new file mode 100755
index 0000000..844e8fc
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_object_manipulator.py
@@ -0,0 +1,514 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.ipam.drivers.infoblox import object_manipulator as om
+from neutron.ipam.drivers.infoblox import objects
+from neutron.tests import base
+
+
+class PayloadMatcher(object):
+    ANYKEY = 'MATCH_ANY_KEY'
+
+    def __init__(self, expected_values):
+        self.args = expected_values
+
+    def __eq__(self, actual):
+        expected = []
+
+        for key, expected_value in self.args.iteritems():
+            expected.append(self._verify_value_is_expected(actual, key,
+                                                           expected_value))
+
+        return all(expected)
+
+    def __repr__(self):
+        return "Expected args: %s" % self.args
+
+    def _verify_value_is_expected(self, d, key, expected_value):
+        found = False
+        if not isinstance(d, dict):
+            return False
+
+        for k in d:
+            if isinstance(d[k], dict):
+                found = self._verify_value_is_expected(d[k], key,
+                                                       expected_value)
+            if isinstance(d[k], list):
+                if k == key and d[k] == expected_value:
+                    return True
+                for el in d[k]:
+                    found = self._verify_value_is_expected(el, key,
+                                                           expected_value)
+
+                    if found:
+                        return True
+            if (key == k or key == self.ANYKEY) and d[k] == expected_value:
+                return True
+        return found
+
+
+class ObjectManipulatorTestCase(base.BaseTestCase):
+    def test_create_net_view_creates_network_view_object(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+        connector.create_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        net_view_name = 'test_net_view_name'
+        ibom.create_network_view(net_view_name, mock.ANY)
+
+        matcher = PayloadMatcher({'name': net_view_name})
+        connector.get_object.assert_called_once_with(
+            'networkview', matcher, None, proxy=False)
+        connector.create_object.assert_called_once_with(
+            'networkview', matcher, mock.ANY)
+
+    def test_create_host_record_creates_host_record_object(self):
+        dns_view_name = 'test_dns_view_name'
+        zone_auth = 'test.dns.zone.com'
+        hostname = 'test_hostname'
+        ip = '192.168.0.1'
+        mac = 'aa:bb:cc:dd:ee:ff'
+
+        sample_host_record = objects.HostRecordIPv4()
+        sample_host_record.hostname = hostname
+        sample_host_record.zone_auth = zone_auth
+        sample_host_record.ip = ip
+
+        connector = mock.Mock()
+        connector.create_object.return_value = sample_host_record.to_dict()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_host_record_for_given_ip(dns_view_name, zone_auth,
+                                             hostname, mac, ip, mock.ANY)
+
+        exp_payload = {
+            'name': 'test_hostname.test.dns.zone.com',
+            'view': dns_view_name,
+            'ipv4addrs': [
+                {'mac': mac, 'configure_for_dhcp': True, 'ipv4addr': ip}
+            ],
+            'extattrs': {}
+        }
+
+        connector.create_object.assert_called_once_with(
+            'record:host', exp_payload, ['ipv4addrs', 'extattrs'])
+
+    def test_create_host_record_range_create_host_record_object(self):
+        dns_view_name = 'test_dns_view_name'
+        zone_auth = 'test.dns.zone.com'
+        hostname = 'test_hostname'
+        mac = 'aa:bb:cc:dd:ee:ff'
+        net_view_name = 'test_net_view_name'
+        first_ip = '192.168.0.1'
+        last_ip = '192.168.0.254'
+
+        sample_host_record = objects.HostRecordIPv4()
+        sample_host_record.hostname = hostname
+        sample_host_record.zone_auth = zone_auth
+        sample_host_record.ip = first_ip
+        sample_host_record.view = dns_view_name
+
+        connector = mock.Mock()
+        connector.create_object.return_value = sample_host_record.to_dict()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_host_record_from_range(
+            dns_view_name, net_view_name, zone_auth, hostname, mac, first_ip,
+            last_ip, mock.ANY)
+
+        next_ip = \
+            'func:nextavailableip:192.168.0.1-192.168.0.254,test_net_view_name'
+        exp_payload = {
+            'name': 'test_hostname.test.dns.zone.com',
+            'view': dns_view_name,
+            'ipv4addrs': [
+                {'mac': mac, 'configure_for_dhcp': True, 'ipv4addr': next_ip}
+            ],
+            'extattrs': mock.ANY
+        }
+
+        connector.create_object.assert_called_once_with(
+            'record:host', exp_payload, ['ipv4addrs', 'extattrs'])
+
+    def test_delete_host_record_deletes_host_record_object(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        dns_view_name = 'test_dns_view_name'
+        ip_address = '192.168.0.254'
+
+        ibom.delete_host_record(dns_view_name, ip_address)
+
+        matcher = PayloadMatcher({'view': dns_view_name,
+                                  PayloadMatcher.ANYKEY: ip_address})
+        connector.get_object.assert_called_once_with(
+            'record:host', matcher, None, proxy=False)
+        connector.delete_object.assert_called_once_with(mock.ANY)
+
+    def test_get_network_gets_network_object(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        net_view_name = 'test_dns_view_name'
+        cidr = '192.168.0.0/24'
+
+        ibom.get_network(net_view_name, cidr)
+
+        matcher = PayloadMatcher({'network_view': net_view_name,
+                                  'network': cidr})
+        connector.get_object.assert_called_once_with('network',
+                                                     matcher,
+                                                     mock.ANY,
+                                                     proxy=False)
+
+    def test_throws_network_not_available_on_get_network(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        net_view_name = 'test_dns_view_name'
+        cidr = '192.168.0.0/24'
+
+        self.assertRaises(exceptions.InfobloxNetworkNotAvailable,
+                          ibom.get_network, net_view_name, cidr)
+
+        matcher = PayloadMatcher({'network_view': net_view_name,
+                                  'network': cidr})
+        connector.get_object.assert_called_once_with('network',
+                                                     matcher,
+                                                     mock.ANY,
+                                                     proxy=False)
+
+    def test_object_is_not_created_if_already_exists(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        net_view_name = 'test_dns_view_name'
+
+        ibom.create_network_view(net_view_name, mock.ANY)
+
+        matcher = PayloadMatcher({'name': net_view_name})
+        connector.get_object.assert_called_once_with(
+            'networkview', matcher, None, proxy=False)
+        assert not connector.create_object.called
+
+    def test_get_member_gets_member_object(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        member = objects.Member(name='member1', ip='some-ip')
+
+        ibom.get_member(member)
+
+        matcher = PayloadMatcher({'host_name': member.name})
+        connector.get_object.assert_called_once_with('member', matcher)
+
+    def test_restart_services_calls_infoblox_function(self):
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        member = objects.Member(name='member1', ip='some-ip')
+
+        ibom.restart_all_services(member)
+
+        connector.call_func.assert_called_once_with(
+            'restartservices', mock.ANY, mock.ANY)
+
+    def test_update_network_updates_object(self):
+        ref = 'infoblox_object_id'
+        opts = 'infoblox_options'
+
+        connector = mock.Mock()
+        ib_network = mock.Mock()
+        ib_network.ref = ref
+        ib_network.options = opts
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.update_network_options(ib_network)
+
+        connector.update_object.assert_called_once_with(ref, {'options': opts},
+                                                        mock.ANY)
+
+    def test_update_network_updates_eas_if_not_null(self):
+        ref = 'infoblox_object_id'
+        opts = 'infoblox_options'
+        eas = 'some-eas'
+
+        connector = mock.Mock()
+        ib_network = mock.Mock()
+        ib_network.ref = ref
+        ib_network.options = opts
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.update_network_options(ib_network, eas)
+
+        connector.update_object.assert_called_once_with(
+            ref, {'options': opts, 'extattrs': eas}, mock.ANY)
+
+    def test_member_is_assigned_as_list_on_network_create(self):
+        net_view = 'net-view-name'
+        cidr = '192.168.1.0/24'
+        nameservers = []
+        members = [
+            objects.Member(name='just-a-single-member-ip', ip='some-ip')
+        ]
+        gateway_ip = '192.168.1.1'
+        expected_members = members[0].ip
+        extattrs = mock.Mock()
+
+        connector = mock.Mock()
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_network(net_view, cidr, nameservers, members, gateway_ip,
+                            extattrs)
+
+        assert not connector.get_object.called
+        matcher = PayloadMatcher({'ipv4addr': expected_members})
+        connector.create_object.assert_called_once_with('network', matcher,
+                                                        None)
+
+    def test_create_ip_range_creates_range_object(self):
+        net_view = 'net-view-name'
+        start_ip = '192.168.1.1'
+        end_ip = '192.168.1.123'
+        disable = False
+
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+        ibom.create_ip_range(net_view, start_ip, end_ip, None,
+                             disable, mock.ANY)
+
+        assert connector.get_object.called
+        matcher = PayloadMatcher({'start_addr': start_ip,
+                                  'end_addr': end_ip,
+                                  'network_view': net_view,
+                                  'disable': disable})
+        connector.create_object.assert_called_once_with('range', matcher,
+                                                        mock.ANY)
+
+    def test_delete_ip_range_deletes_infoblox_object(self):
+        net_view = 'net-view-name'
+        start_ip = '192.168.1.1'
+        end_ip = '192.168.1.123'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.delete_ip_range(net_view, start_ip, end_ip)
+
+        matcher = PayloadMatcher({'start_addr': start_ip,
+                                  'end_addr': end_ip,
+                                  'network_view': net_view})
+        connector.get_object.assert_called_once_with('range', matcher,
+                                                     None, proxy=False)
+        connector.delete_object.assert_called_once_with(mock.ANY)
+
+    def test_delete_network_deletes_infoblox_network(self):
+        net_view = 'net-view-name'
+        cidr = '192.168.1.0/24'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.delete_network(net_view, cidr)
+
+        matcher = PayloadMatcher({'network_view': net_view,
+                                  'network': cidr})
+        connector.get_object.assert_called_once_with('network', matcher,
+                                                     None, proxy=False)
+        connector.delete_object.assert_called_once_with(mock.ANY)
+
+    def test_delete_network_view_deletes_infoblox_object(self):
+        net_view = 'net-view-name'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.delete_network_view(net_view)
+
+        matcher = PayloadMatcher({'name': net_view})
+        connector.get_object.assert_called_once_with(
+            'networkview', matcher, None, proxy=False)
+        connector.delete_object.assert_called_once_with(mock.ANY)
+
+    def test_bind_names_updates_host_record(self):
+        dns_view_name = 'dns-view-name'
+        fqdn = 'host.global.com'
+        ip = '192.168.1.1'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = mock.MagicMock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.bind_name_with_host_record(dns_view_name, ip,
+                                        fqdn, mock.ANY)
+
+        matcher = PayloadMatcher({'view': dns_view_name,
+                                  PayloadMatcher.ANYKEY: ip})
+        connector.get_object.assert_called_once_with('record:host',
+                                                     matcher,
+                                                     None,
+                                                     proxy=False)
+
+        matcher = PayloadMatcher({'name': fqdn})
+        connector.update_object.assert_called_once_with(mock.ANY,
+                                                        matcher,
+                                                        mock.ANY)
+
+    def test_create_dns_zone_creates_zone_auth_object(self):
+        dns_view_name = 'dns-view-name'
+        fqdn = 'host.global.com'
+        member = objects.Member(name='member_name', ip='some-ip')
+        zone_format = 'IPV4'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_dns_zone(dns_view_name, fqdn, member,
+                             zone_format=zone_format)
+
+        matcher = PayloadMatcher({'view': dns_view_name,
+                                  'fqdn': fqdn})
+        connector.get_object.assert_called_once_with('zone_auth',
+                                                     matcher,
+                                                     None,
+                                                     proxy=False)
+
+        matcher = PayloadMatcher({'view': dns_view_name,
+                                  'fqdn': fqdn,
+                                  'zone_format': zone_format,
+                                  'name': member.name})
+        connector.create_object.assert_called_once_with('zone_auth',
+                                                        matcher,
+                                                        None)
+
+    def test_create_dns_zone_with_grid_secondaries(self):
+        dns_view_name = 'dns-view-name'
+        fqdn = 'host.global.com'
+        primary_dns_member = objects.Member(name='member_primary',
+                                            ip='some-ip')
+        secondary_dns_members = [objects.Member(name='member_secondary',
+                                                ip='some-ip')]
+        zone_format = 'IPV4'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_dns_zone(dns_view_name, fqdn, primary_dns_member,
+                             secondary_dns_members,
+                             zone_format=zone_format)
+
+        matcher = PayloadMatcher({'view': dns_view_name,
+                                  'fqdn': fqdn})
+        connector.get_object.assert_called_once_with('zone_auth',
+                                                     matcher,
+                                                     None,
+                                                     proxy=False)
+
+        payload = {'view': dns_view_name,
+                   'fqdn': fqdn,
+                   'zone_format': zone_format,
+                   'grid_primary': [{'name': primary_dns_member.name,
+                                     '_struct': 'memberserver'}],
+                   'grid_secondaries': [{'name': member.name,
+                                         '_struct': 'memberserver'}
+                                        for member in secondary_dns_members],
+                   'extattrs': {}
+                   }
+        connector.create_object.assert_called_once_with('zone_auth',
+                                                        payload,
+                                                        None)
+
+    def test_create_host_record_throws_exception_on_error(self):
+        dns_view_name = 'dns-view-name'
+        hostname = 'host.global.com'
+        mac = 'aa:bb:cc:dd:ee:ff'
+        ip = '192.168.1.1'
+        zone_auth = 'my.auth.zone.com'
+
+        connector = mock.Mock()
+        response = {'text': "Cannot find 1 available IP"}
+
+        connector.create_object.side_effect = \
+            exceptions.InfobloxCannotCreateObject(response=response,
+                                                  objtype='host:record',
+                                                  content='adsfasd',
+                                                  code='1234')
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        self.assertRaises(exceptions.InfobloxCannotAllocateIp,
+                          ibom.create_host_record_for_given_ip,
+                          dns_view_name, zone_auth, hostname, mac, ip,
+                          mock.ANY)
+
+    def test_create_dns_view_creates_view_object(self):
+        net_view_name = 'net-view-name'
+        dns_view_name = 'dns-view-name'
+
+        connector = mock.Mock()
+        connector.get_object.return_value = None
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.create_dns_view(net_view_name, dns_view_name)
+
+        matcher = PayloadMatcher({'name': dns_view_name,
+                                  'network_view': net_view_name})
+        connector.get_object.assert_called_once_with('view', matcher,
+                                                     None, proxy=False)
+        connector.create_object.assert_called_once_with('view', matcher,
+                                                        None)
+
+    def test_default_net_view_is_never_deleted(self):
+        connector = mock.Mock()
+
+        ibom = om.InfobloxObjectManipulator(connector)
+
+        ibom.delete_network_view('default')
+
+        assert not connector.delete_object.called
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_objects.py b/neutron/tests/unit/ipam/drivers/infoblox/test_objects.py
new file mode 100755
index 0000000..c8531ad
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_objects.py
@@ -0,0 +1,353 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+from testtools import matchers
+
+from neutron.ipam.drivers.infoblox import objects
+from neutron.openstack.common import jsonutils
+from neutron.tests import base
+
+
+class InfobloxNetworkObjectTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(InfobloxNetworkObjectTestCase, self).setUp()
+        self.network_object_dict = jsonutils.loads("""[
+        {
+            "_ref": "network/ZG5zLldHdvcmskMTAuMzkuMTE:10.39.11.0/24/default",
+            "members": [
+                {
+                    "_struct": "dhcpmember",
+                    "ipv4addr": "10.39.11.123",
+                    "name": "infoblox.localdomain"
+                }
+            ],
+            "options": [
+                {
+                    "name": "dhcp-lease-time",
+                    "num": 51,
+                    "use_option": false,
+                    "value": "43200",
+                    "vendor_class": "DHCP"
+                },
+                {
+                    "name": "domain-name-servers",
+                    "num": 6,
+                    "use_option": true,
+                    "value": "10.39.11.123,10.39.11.124,10.39.11.125",
+                    "vendor_class": "DHCP"
+                },
+                {
+                    "name": "routers",
+                    "num": 3,
+                    "use_option": false,
+                    "value": "10.39.11.1",
+                    "vendor_class": "DHCP"
+                }
+            ]
+        }
+    ]""")[0]
+
+    def _get_nameservers_opt(self, network):
+        nameservers_opts = filter(lambda opt:
+                                  opt['name'] ==
+                                  objects.Network.DNS_NAMESERVERS_OPTION,
+                                  network['options'])
+        if nameservers_opts:
+            return nameservers_opts[0]
+        return None
+
+    def test_has_members(self):
+        net = objects.Network.from_dict(self.network_object_dict)
+        self.assertTrue(net.members)
+
+    def test_update_member_ip_modifies_member_ip(self):
+        net = objects.Network.from_dict(self.network_object_dict)
+        new_ip = '!!!NEW_IP!!!'
+        net.update_member_ip_in_dns_nameservers(new_ip)
+        self.assertIn(new_ip, net.dns_nameservers)
+
+    def test_get_dns_nameservers(self):
+        net = objects.Network.from_dict(self.network_object_dict)
+        servers = "10.39.11.123,10.39.11.124,10.39.11.125".split(',')
+        self.assertEqual(servers, net.dns_nameservers)
+
+    def test_get_dns_nameservers_no_option(self):
+        nameservers_opt = self._get_nameservers_opt(self.network_object_dict)
+        self.network_object_dict['options'].remove(nameservers_opt)
+        net = objects.Network.from_dict(self.network_object_dict)
+        self.assertEqual([], net.dns_nameservers)
+
+    def test_get_dns_nameservers_use_option_false(self):
+        nameservers_opt = self._get_nameservers_opt(self.network_object_dict)
+        nameservers_opt['use_option'] = False
+        net = objects.Network.from_dict(self.network_object_dict)
+        self.assertEqual([], net.dns_nameservers)
+
+    def test_set_dns_nameservers(self):
+        net = objects.Network.from_dict(self.network_object_dict)
+        net.dns_nameservers = ['1.1.1.1', '3.3.3.3']
+        net_dict = net.to_dict()
+        nameservers_opt = self._get_nameservers_opt(net_dict)
+        self.assertEqual('1.1.1.1,3.3.3.3', nameservers_opt['value'])
+        self.assertTrue(nameservers_opt['use_option'])
+
+    def test_set_dns_nameservers_empty_val(self):
+        net = objects.Network.from_dict(self.network_object_dict)
+        net.dns_nameservers = []
+        net_dict = net.to_dict()
+        nameservers_opt = self._get_nameservers_opt(net_dict)
+        self.assertFalse(nameservers_opt['use_option'])
+
+    def test_set_dns_nameservers_no_previous_option(self):
+        nameservers_opt = self._get_nameservers_opt(self.network_object_dict)
+        self.network_object_dict['options'].remove(nameservers_opt)
+        net = objects.Network.from_dict(self.network_object_dict)
+        net.dns_nameservers = ['7.7.7.7', '8.8.8.8']
+        net_dict = net.to_dict()
+        nameservers_opt = self._get_nameservers_opt(net_dict)
+        self.assertEqual('7.7.7.7,8.8.8.8', nameservers_opt['value'])
+        self.assertTrue(nameservers_opt['use_option'])
+
+    def test_set_dns_nameservers_no_previous_option_and_empty_val(self):
+        nameservers_opt = self._get_nameservers_opt(self.network_object_dict)
+        self.network_object_dict['options'].remove(nameservers_opt)
+        net = objects.Network.from_dict(self.network_object_dict)
+        net.dns_nameservers = []
+        net_dict = net.to_dict()
+        nameservers_opt = self._get_nameservers_opt(net_dict)
+        self.assertIsNone(nameservers_opt)
+
+
+class InfobloxIPv4ObjectTestCase(base.BaseTestCase):
+    def test_removes_correct_object_from_list_of_ips(self):
+        removed_ip = '192.168.1.2'
+        ips = [
+            objects.IPv4(ip='192.168.1.1'),
+            objects.IPv4(ip=removed_ip),
+            objects.IPv4(ip='192.168.1.3')
+        ]
+
+        ips.remove(removed_ip)
+
+        self.assertEqual(len(ips), 2)
+        for ip in ips:
+            self.assertTrue(ip.ip != removed_ip)
+
+
+class InfobloxIPv4HostRecordObjectTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(InfobloxIPv4HostRecordObjectTestCase, self).setUp()
+        host_record_ref = ("record:host/ZG5zLmhvc3QkLjY3OC5jb20uZ2xvYmFsLmNs"
+                           "b3VkLnRlc3RzdWJuZXQudGVzdF9ob3N0X25hbWU:"
+                           "test_host_name.testsubnet.cloud.global.com/"
+                           "default.687401e9f7a7471abbf301febf99854e")
+        ipv4addrs_ref = ("record:host_ipv4addr/ZG5zLmhvc3RfYWRkcmVzcyQuNjc"
+                         "4LmNvbS5nbG9iYWwuY2xvdWQudGVzdHN1Ym5ldC50ZXN0X2h"
+                         "vc3RfbmFtZS4xOTIuMTY4LjAuNS4:192.168.0.5/"
+                         "test_host_name.testsubnet.cloud.global.com/"
+                         "default.687401e9f7a7471abbf301febf99854e")
+        self.host_record = jsonutils.loads("""{
+            "_ref": "%s",
+            "ipv4addrs": [
+                {
+                    "_ref": "%s",
+                    "configure_for_dhcp": false,
+                    "host": "test_host_name.testsubnet.cloud.global.com",
+                    "ipv4addr": "192.168.0.5",
+                    "mac": "aa:bb:cc:dd:ee:ff"
+                }
+            ]
+        }
+        """ % (host_record_ref, ipv4addrs_ref))
+
+    def test_constructs_object_from_dict(self):
+        host_record = objects.HostRecordIPv4.from_dict(self.host_record)
+        self.assertIsNotNone(host_record)
+
+    def test_hostname_is_set_from_dict(self):
+        expected_hostname = 'expected_hostname'
+        expected_dns_zone = 'expected.dns.zone.com'
+        self.host_record['ipv4addrs'][0]['host'] = '.'.join(
+            [expected_hostname, expected_dns_zone])
+        host_record = objects.HostRecordIPv4.from_dict(self.host_record)
+
+        self.assertEqual(expected_hostname, host_record.hostname)
+        self.assertEqual(expected_dns_zone, host_record.zone_auth)
+
+    def test_all_attributes_are_set_from_dict(self):
+        expected_attributes = ['hostname', 'dns_view', 'mac', 'ip']
+        hr = objects.HostRecordIPv4.from_dict(self.host_record)
+        self.assertTrue(all([expected in dir(hr)
+                             for expected in expected_attributes]))
+
+
+class InfobloxIPv6HostRecordObjectTestCase(base.BaseTestCase):
+    def setUp(self):
+        super(InfobloxIPv6HostRecordObjectTestCase, self).setUp()
+        host_record_ref = ("record:host/ZG5zLmhvc3QkLjY3OC5jb20uZ2xvYmFsLmNs"
+                           "b3VkLnRlc3RzdWJuZXQudGVzdF9ob3N0X25hbWU:"
+                           "test_host_name.testsubnet.cloud.global.com/"
+                           "default.687401e9f7a7471abbf301febf99854e")
+        ipv6addrs_ref = ("record:host_ipv4addr/ZG5zLmhvc3RfYWRkcmVzcyQuNjc"
+                         "4LmNvbS5nbG9iYWwuY2xvdWQudGVzdHN1Ym5ldC50ZXN0X2h"
+                         "vc3RfbmFtZS4xOTIuMTY4LjAuNS4:2001:DB8::3/"
+                         "test_host_name.testsubnet.cloud.global.com/"
+                         "default.687401e9f7a7471abbf301febf99854e")
+        self.host_record = jsonutils.loads("""{
+            "_ref": "%s",
+            "ipv6addrs": [
+                {
+                    "_ref": "%s",
+                    "configure_for_dhcp": false,
+                    "host": "test_host_name.testsubnet.cloud.global.com",
+                    "ipv6addr": "2001:DB8::3",
+                    "mac": "aa:bb:cc:dd:ee:ff"
+                }
+            ]
+        }
+        """ % (host_record_ref, ipv6addrs_ref))
+
+    def test_constructs_object_from_dict(self):
+        host_record = objects.HostRecordIPv6.from_dict(self.host_record)
+        self.assertIsNotNone(host_record)
+
+    def test_hostname_is_set_from_dict(self):
+        expected_hostname = 'expected_hostname'
+        expected_dns_zone = 'expected.dns.zone.com'
+        self.host_record['ipv6addrs'][0]['host'] = '.'.join(
+            [expected_hostname, expected_dns_zone])
+        host_record = objects.HostRecordIPv6.from_dict(self.host_record)
+
+        self.assertEqual(expected_hostname, host_record.hostname)
+        self.assertEqual(expected_dns_zone, host_record.zone_auth)
+
+    def test_all_attributes_are_set_from_dict(self):
+        expected_attributes = ['hostname', 'dns_view', 'mac', 'ip']
+        hr = objects.HostRecordIPv6.from_dict(self.host_record)
+        self.assertTrue(all([expected in dir(hr)
+                             for expected in expected_attributes]))
+
+
+class FixedAddressIPv4TestCase(base.BaseTestCase):
+    def test_builds_valid_fa_from_infoblox_returned_json(self):
+        fixed_address_ref = ("fixedaddress/ZG5zLmZpeGVkX2FkZHJlc3MkMTAuMC4wLj"
+                             "EwMC42ODAuLg:10.0.0.100/rv-test-netview")
+        ip = "10.0.0.100"
+        fixed_address = jsonutils.loads("""{
+            "_ref": "%s",
+            "ipv4addr": "%s"
+        }""" % (fixed_address_ref, ip))
+
+        fa = objects.FixedAddressIPv4.from_dict(fixed_address)
+        self.assertEqual(fa.ip, ip)
+
+    def test_dict_contains_mac_ip_and_net_view(self):
+        expected_ip = "1.2.3.4"
+        expected_mac = "aa:bb:cc:dd:ee:ff"
+        expected_net_view = "test-net-view-name"
+        expected_extattrs = "test-extattrs"
+
+        expected_dict = {
+            'mac': expected_mac,
+            'ipv4addr': expected_ip,
+            'network_view': expected_net_view,
+            'extattrs': expected_extattrs
+        }
+
+        fa = objects.FixedAddressIPv4()
+        fa.ip = expected_ip
+        fa.net_view = expected_net_view
+        fa.mac = expected_mac
+        fa.extattrs = expected_extattrs
+
+        self.assertThat(fa.to_dict(), matchers.KeysEqual(expected_dict))
+        self.assertThat(fa.to_dict(), matchers.Equals(expected_dict))
+
+
+class FixedAddressIPv6TestCase(base.BaseTestCase):
+    def test_builds_valid_fa_from_infoblox_returned_json(self):
+        fixed_address_ref = ("fixedaddress/ZG5zLmZpeGVkX2FkZHJlc3MkMTAuMC4wLj"
+                             "EwMC42ODAuLg:10.0.0.100/rv-test-netview")
+        ip = "2001:DB8::3"
+        fixed_address = jsonutils.loads("""{
+            "_ref": "%s",
+            "ipv6addr": "%s"
+        }""" % (fixed_address_ref, ip))
+
+        fa = objects.FixedAddressIPv6.from_dict(fixed_address)
+        self.assertEqual(fa.ip, ip)
+
+    @mock.patch.object(objects, 'generate_duid',
+                       mock.Mock(return_value=None))
+    def test_dict_contains_mac_ip_and_net_view(self):
+        expected_ip = "2001:DB8::3"
+        duid = "aa:bb:cc:dd:ee:ff"
+        expected_duid = "00:03:00:01:aa:bb:cc:dd:ee:ff"
+        expected_net_view = "test-net-view-name"
+        expected_extattrs = "test-extattrs"
+
+        objects.generate_duid.return_value = expected_duid
+
+        expected_dict = {
+            'duid': expected_duid,
+            'ipv6addr': expected_ip,
+            'network_view': expected_net_view,
+            'extattrs': expected_extattrs
+        }
+
+        fa = objects.FixedAddressIPv6()
+        fa.ip = expected_ip
+        fa.net_view = expected_net_view
+        fa.mac = duid
+        fa.extattrs = expected_extattrs
+
+        self.assertThat(fa.to_dict(), matchers.KeysEqual(expected_dict))
+        self.assertThat(fa.to_dict(), matchers.Equals(expected_dict))
+
+
+class MemberTestCase(base.BaseTestCase):
+    def test_two_identical_members_are_equal(self):
+        ip = 'some-ip'
+        name = 'some-name'
+
+        m1 = objects.Member(ip, name)
+        m2 = objects.Member(ip, name)
+
+        self.assertEqual(m1, m2)
+
+
+class IPAllocationObjectTestCase(base.BaseTestCase):
+    def test_next_available_ip_returns_properly_formatted_string(self):
+        net_view = 'expected_net_view_name'
+        first_ip = '1.2.3.4'
+        last_ip = '1.2.3.14'
+        cidr = '1.2.3.0/24'
+
+        naip = objects.IPAllocationObject.next_available_ip_from_range(
+            net_view, first_ip, last_ip)
+
+        self.assertTrue(isinstance(naip, basestring))
+        self.assertTrue(naip.startswith('func:nextavailableip:'))
+        self.assertTrue(naip.endswith(
+            '{first_ip}-{last_ip},{net_view}'.format(**locals())))
+
+        naip = objects.IPAllocationObject.next_available_ip_from_cidr(
+            net_view, cidr)
+
+        self.assertTrue(isinstance(naip, basestring))
+        self.assertTrue(naip.startswith('func:nextavailableip:'))
+        self.assertTrue(naip.endswith(
+            '{cidr},{net_view}'.format(**locals())))
diff --git a/neutron/tests/unit/ipam/drivers/infoblox/test_pattern_builder.py b/neutron/tests/unit/ipam/drivers/infoblox/test_pattern_builder.py
new file mode 100644
index 0000000..acae9ac
--- /dev/null
+++ b/neutron/tests/unit/ipam/drivers/infoblox/test_pattern_builder.py
@@ -0,0 +1,114 @@
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+from neutron.ipam.drivers.infoblox import config
+from neutron.ipam.drivers.infoblox import exceptions
+from neutron.tests import base
+
+
+class PatternBuilderTestCase(base.BaseTestCase):
+    def test_dots_in_ip_address_replaced_with_dashes(self):
+        context = mock.MagicMock()
+        subnet = mock.MagicMock()
+        ip = '192.168.1.1'
+
+        res = config.PatternBuilder("{ip_address}").build(
+            context, subnet, ip_addr=ip)
+
+        self.assertEqual(res, ip.replace('.', '-'))
+
+    def test_raises_error_if_pattern_is_invalid(self):
+        context = mock.MagicMock()
+        subnet = mock.MagicMock()
+
+        pb = config.PatternBuilder("{}")
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          pb.build, context, subnet)
+
+        pb = config.PatternBuilder("start..end")
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          pb.build, context, subnet)
+
+        pb = config.PatternBuilder("{non-existing-variable}")
+        self.assertRaises(exceptions.InfobloxConfigException,
+                          pb.build, context, subnet)
+
+    def test_subnet_id_used_if_subnet_has_no_name(self):
+        context = mock.MagicMock()
+        subnet = mock.MagicMock()
+        subnet_id = 'some-id'
+
+        def get_id(item):
+            if item == 'id':
+                return subnet_id
+            return None
+        subnet.__getitem__.side_effect = get_id
+
+        pb = config.PatternBuilder("{subnet_name}")
+        built = pb.build(context, subnet)
+
+        self.assertEqual(built, subnet_id)
+
+    def test_value_is_built_using_pattern(self):
+        context = mock.MagicMock()
+        subnet = mock.MagicMock()
+        subnet_name = 'subnet-name'
+        ip_address = 'ip_address'
+
+        def get_id(item):
+            if item == 'name':
+                return subnet_name
+            else:
+                return None
+        subnet.__getitem__.side_effect = get_id
+
+        pattern = "host-{ip_address}.{subnet_name}.custom_stuff"
+        pb = config.PatternBuilder(pattern)
+        built = pb.build(context, subnet, ip_addr=ip_address)
+
+        self.assertEqual(built, pattern.format(subnet_name=subnet_name,
+                                               ip_address=ip_address))
+
+    def test_all_required_pattern_variables_are_supported(self):
+        required_variables = [
+            'tenant_id', 'instance_id', 'ip_address',
+            'ip_address_octet1', 'ip_address_octet2', 'ip_address_octet3',
+            'ip_address_octet4', 'subnet_id', 'subnet_name', 'user_id',
+            'network_id', 'network_name'
+        ]
+
+        pattern = '.'.join(['{%s}' % v for v in required_variables])
+        context = mock.Mock()
+        context.user_id = 'user-id'
+        subnet = {
+            'network_id': 'some-net-id',
+            'tenant_id': 'some-tenant-id',
+            'id': 'some-subnet-id',
+            'name': 'some-subnet-name'
+        }
+        port = {
+            'id': 'some-port-id',
+            'device_id': 'some-device-id'
+        }
+        ip_addr = '10.0.0.3'
+
+        pb = config.PatternBuilder(pattern)
+
+        try:
+            pb.build(context, subnet, port, ip_addr)
+        except exceptions.InvalidPattern as e:
+            self.fail('Unexpected exception: {}'.format(e))
diff --git a/neutron/tests/unit/ipam/test_base.py b/neutron/tests/unit/ipam/test_base.py
new file mode 100644
index 0000000..24a7a8a
--- /dev/null
+++ b/neutron/tests/unit/ipam/test_base.py
@@ -0,0 +1,181 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+# Copyright 2014 OpenStack LLC.
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+from neutron.common import exceptions as q_exc
+from neutron.ipam.drivers import neutron_ipam
+from neutron.tests import base
+
+
+class SubnetCreateTestCase(base.BaseTestCase):
+    def test_subnet_is_created(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.MagicMock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        ipam_driver.create_subnet(context, subnet)
+
+        assert ipam_controller.create_subnet.called_once
+
+    def test_dhcp_is_configured(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.MagicMock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        ipam_driver.create_subnet(context, subnet)
+
+        assert dhcp_controller.configure_dhcp.called_once
+
+
+class SubnetDeleteTestCase(base.BaseTestCase):
+    def test_dns_zones_are_deleted(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.Mock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet_id = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        db_manager.subnet_has_ports_allocated.return_value = False
+        db_manager.get_subnet_ports.return_value = []
+        ipam_driver.delete_subnet(context, subnet_id)
+
+        assert dns_controller.delete_dns_zones.called_once
+
+    def test_dhcp_gets_disabled(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.Mock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet_id = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        db_manager.subnet_has_ports_allocated.return_value = False
+        db_manager.get_subnet_ports.return_value = []
+        ipam_driver.delete_subnet(context, subnet_id)
+
+        assert dhcp_controller.disable_dhcp.called_once
+
+    def test_subnet_is_deleted_from_ipam(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.Mock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet_id = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        db_manager.subnet_has_ports_allocated.return_value = False
+        db_manager.get_subnet_ports.return_value = []
+        ipam_driver.delete_subnet(context, subnet_id)
+
+        assert ipam_controller.delete_subnet.called_once
+
+    def test_raises_error_if_subnet_has_active_ports(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.MagicMock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        subnet_id = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        db_manager.subnet_has_ports_allocated.return_value = True
+        db_manager.get_subnet_ports.return_value = [mock.MagicMock()]
+        self.assertRaises(q_exc.SubnetInUse, ipam_driver.delete_subnet,
+                          context, subnet_id)
+
+
+class AllocateIPTestCase(base.BaseTestCase):
+    def test_allocates_ip(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.Mock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        host = mock.MagicMock()
+        ip = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        ipam_driver.allocate_ip(context, host, ip)
+
+        assert ipam_controller.allocate_ip.called_once
+
+    def test_binds_mac(self):
+        dns_controller = mock.Mock()
+        dhcp_controller = mock.Mock()
+        ipam_controller = mock.Mock()
+        db_manager = mock.Mock()
+        context = mock.MagicMock()
+        host = mock.MagicMock()
+        ip = mock.Mock()
+
+        ipam_driver = neutron_ipam.NeutronIPAM(
+            dhcp_controller=dhcp_controller,
+            dns_controller=dns_controller,
+            ipam_controller=ipam_controller,
+            db_mgr=db_manager)
+
+        ipam_driver.allocate_ip(context, host, ip)
+
+        assert dhcp_controller.bind_mac.called_once
diff --git a/neutron/tests/unit/test_db_plugin.py b/neutron/tests/unit/test_db_plugin.py
index 1f91e74..812fb2a 100644
--- a/neutron/tests/unit/test_db_plugin.py
+++ b/neutron/tests/unit/test_db_plugin.py
@@ -20,6 +20,7 @@ import itertools
 import mock
 from oslo.config import cfg
 from testtools import matchers
+from testtools import testcase
 import webob.exc
 
 import neutron
@@ -33,8 +34,10 @@ from neutron.common import ipv6_utils
 from neutron.common import test_lib
 from neutron.common import utils
 from neutron import context
+from neutron.db import api as db
 from neutron.db import db_base_plugin_v2
 from neutron.db import models_v2
+from neutron.ipam.drivers import neutron_ipam
 from neutron import manager
 from neutron.openstack.common import importutils
 from neutron.tests import base
@@ -90,6 +93,12 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
         if not plugin:
             plugin = DB_PLUGIN_KLASS
 
+        # Create the default configurations
+        args = ['--config-file', etcdir('neutron.conf.test')]
+        # If test_config specifies some config-file, use it, as well
+        for config_file in test_config.get('config_files', []):
+            args.extend(['--config-file', config_file])
+        config.parse(args=args)
         # Update the plugin
         self.setup_coreplugin(plugin)
         cfg.CONF.set_override(
@@ -145,6 +154,9 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
         self._skip_native_pagination = None
         self._skip_native_sortin = None
         self.ext_api = None
+        # NOTE(jkoelker) for a 'pluggable' framework, Neutron sure
+        #                doesn't like when the plugin changes ;)
+        db.clear_db()
         # Restore the original attribute map
         attributes.RESOURCE_ATTRIBUTE_MAP = self._attribute_map_bk
         super(NeutronDbPluginV2TestCase, self).tearDown()
@@ -521,10 +533,17 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
     def network(self, name='net1',
                 admin_state_up=True,
                 fmt=None,
+                do_delete=True,
                 **kwargs):
         network = self._make_network(fmt or self.fmt, name,
                                      admin_state_up, **kwargs)
         yield network
+        if do_delete:
+            # The do_delete parameter allows you to control whether the
+            # created network is immediately deleted again. Therefore, this
+            # function is also usable in tests, which require the creation
+            # of many networks.
+            self._delete('networks', network['network']['id'])
 
     @contextlib.contextmanager
     def subnet(self, network=None,
@@ -537,6 +556,7 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
                dns_nameservers=None,
                host_routes=None,
                shared=None,
+               do_delete=True,
                ipv6_ra_mode=None,
                ipv6_address_mode=None):
         with optional_ctx(network, self.network) as network_to_use:
@@ -553,13 +573,18 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
                                        ipv6_ra_mode=ipv6_ra_mode,
                                        ipv6_address_mode=ipv6_address_mode)
             yield subnet
+            if do_delete:
+                self._delete('subnets', subnet['subnet']['id'])
 
     @contextlib.contextmanager
-    def port(self, subnet=None, fmt=None, **kwargs):
+    def port(self, subnet=None, fmt=None, no_delete=False,
+             **kwargs):
         with optional_ctx(subnet, self.subnet) as subnet_to_use:
             net_id = subnet_to_use['subnet']['network_id']
             port = self._make_port(fmt or self.fmt, net_id, **kwargs)
             yield port
+            if not no_delete:
+                self._delete('ports', port['port']['id'])
 
     def _test_list_with_sort(self, resource,
                              items, sorts, resources=None, query_params=''):
@@ -576,7 +601,8 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
         resource = resource.replace('-', '_')
         resources = resources.replace('-', '_')
         expected_res = [item[resource]['id'] for item in items]
-        self.assertEqual(expected_res, [n['id'] for n in res[resources]])
+        self.assertEqual(sorted([n['id'] for n in res[resources]]),
+                         sorted(expected_res))
 
     def _test_list_with_pagination(self, resource, items, sort,
                                    limit, expected_page_num,
@@ -610,8 +636,9 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
                         self.assertEqual(len(res[resources]),
                                          limit)
         self.assertEqual(expected_page_num, page_num)
-        self.assertEqual([item[resource][verify_key] for item in items],
-                         [n[verify_key] for n in items_res])
+        self.assertEqual(sorted([item[resource][verify_key] 
+                                 for item in items]),
+                         sorted([n[verify_key] for n in items_res]))
 
     def _test_list_with_pagination_reverse(self, resource, items, sort,
                                            limit, expected_page_num,
@@ -650,7 +677,8 @@ class NeutronDbPluginV2TestCase(testlib_api.WebTestCase,
         self.assertEqual(expected_page_num, page_num)
         expected_res = [item[resource]['id'] for item in items]
         expected_res.reverse()
-        self.assertEqual(expected_res, [n['id'] for n in item_res])
+        self.assertEqual(sorted(expected_res),
+                         sorted([n['id'] for n in item_res]))
 
 
 class TestBasicGet(NeutronDbPluginV2TestCase):
@@ -777,7 +805,7 @@ class TestPortsV2(NeutronDbPluginV2TestCase):
             self.assertEqual('myname', port['port']['name'])
 
     def test_create_port_as_admin(self):
-        with self.network() as network:
+        with self.network(do_delete=False) as network:
             self._create_port(self.fmt,
                               network['network']['id'],
                               webob.exc.HTTPCreated.code,
@@ -989,17 +1017,20 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             'neutron.api.v2.base.Controller._get_sorting_helper',
             new=_fake_get_sorting_helper)
         helper_patcher.start()
-        cfg.CONF.set_default('allow_overlapping_ips', True)
-        with contextlib.nested(self.port(admin_state_up='True',
-                                         mac_address='00:00:00:00:00:01'),
-                               self.port(admin_state_up='False',
-                                         mac_address='00:00:00:00:00:02'),
-                               self.port(admin_state_up='False',
-                                         mac_address='00:00:00:00:00:03')
-                               ) as (port1, port2, port3):
-            self._test_list_with_sort('port', (port3, port2, port1),
-                                      [('admin_state_up', 'asc'),
-                                       ('mac_address', 'desc')])
+        try:
+            cfg.CONF.set_default('allow_overlapping_ips', True)
+            with contextlib.nested(self.port(admin_state_up='True',
+                                             mac_address='00:00:00:00:00:01'),
+                                   self.port(admin_state_up='False',
+                                             mac_address='00:00:00:00:00:02'),
+                                   self.port(admin_state_up='False',
+                                             mac_address='00:00:00:00:00:03')
+                                   ) as (port1, port2, port3):
+                self._test_list_with_sort('port', (port3, port2, port1),
+                                          [('admin_state_up', 'asc'),
+                                           ('mac_address', 'desc')])
+        finally:
+            helper_patcher.stop()
 
     def test_list_ports_with_pagination_native(self):
         if self._skip_native_pagination:
@@ -1018,14 +1049,17 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        cfg.CONF.set_default('allow_overlapping_ips', True)
-        with contextlib.nested(self.port(mac_address='00:00:00:00:00:01'),
-                               self.port(mac_address='00:00:00:00:00:02'),
-                               self.port(mac_address='00:00:00:00:00:03')
-                               ) as (port1, port2, port3):
-            self._test_list_with_pagination('port',
-                                            (port1, port2, port3),
-                                            ('mac_address', 'asc'), 2, 2)
+        try:
+            cfg.CONF.set_default('allow_overlapping_ips', True)
+            with contextlib.nested(self.port(mac_address='00:00:00:00:00:01'),
+                                   self.port(mac_address='00:00:00:00:00:02'),
+                                   self.port(mac_address='00:00:00:00:00:03')
+                                   ) as (port1, port2, port3):
+                self._test_list_with_pagination('port',
+                                                (port1, port2, port3),
+                                                ('mac_address', 'asc'), 2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_list_ports_with_pagination_reverse_native(self):
         if self._skip_native_pagination:
@@ -1045,15 +1079,18 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        cfg.CONF.set_default('allow_overlapping_ips', True)
-        with contextlib.nested(self.port(mac_address='00:00:00:00:00:01'),
-                               self.port(mac_address='00:00:00:00:00:02'),
-                               self.port(mac_address='00:00:00:00:00:03')
-                               ) as (port1, port2, port3):
-            self._test_list_with_pagination_reverse('port',
-                                                    (port1, port2, port3),
-                                                    ('mac_address', 'asc'),
-                                                    2, 2)
+        try:
+            cfg.CONF.set_default('allow_overlapping_ips', True)
+            with contextlib.nested(self.port(mac_address='00:00:00:00:00:01'),
+                                   self.port(mac_address='00:00:00:00:00:02'),
+                                   self.port(mac_address='00:00:00:00:00:03')
+                                   ) as (port1, port2, port3):
+                self._test_list_with_pagination_reverse('port',
+                                                        (port1, port2, port3),
+                                                        ('mac_address', 'asc'),
+                                                        2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_show_port(self):
         with self.port() as port:
@@ -1062,7 +1099,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
             self.assertEqual(port['port']['id'], sport['port']['id'])
 
     def test_delete_port(self):
-        with self.port() as port:
+        with self.port(no_delete=True) as port:
             self._delete('ports', port['port']['id'])
             self._show('ports', port['port']['id'],
                        expected_code=webob.exc.HTTPNotFound.code)
@@ -1309,8 +1346,9 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         def fake_gen_mac(context, net_id):
             raise n_exc.MacAddressGenerationFailure(net_id=net_id)
 
-        with mock.patch.object(neutron.db.db_base_plugin_v2.NeutronDbPluginV2,
-                               '_generate_mac', new=fake_gen_mac):
+        with mock.patch.object(
+                neutron.db.db_base_plugin_v2.NeutronCorePluginV2,
+                '_generate_mac', new=fake_gen_mac):
             res = self._create_network(fmt=self.fmt, name='net1',
                                        admin_state_up=True)
             network = self.deserialize(self.fmt, res)
@@ -1333,6 +1371,32 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
                 res = self._create_port(self.fmt, net_id=net_id, **kwargs)
                 self.assertEqual(res.status_int, webob.exc.HTTPConflict.code)
 
+    def test_requested_subnet_delete(self):
+        with self.subnet() as subnet:
+            with self.port(subnet=subnet) as port:
+                ips = port['port']['fixed_ips']
+                self.assertEqual(len(ips), 1)
+                self.assertEqual(ips[0]['ip_address'], '10.0.0.2')
+                self.assertEqual(ips[0]['subnet_id'], subnet['subnet']['id'])
+                req = self.new_delete_request('subnet',
+                                              subnet['subnet']['id'])
+                res = req.get_response(self.api)
+                self.assertEqual(res.status_int, webob.exc.HTTPNotFound.code)
+
+    def test_generated_duplicate_ip_ipv6(self):
+        with self.subnet(ip_version=6,
+                         cidr="2014::/64",
+                         ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
+            with self.port(subnet=subnet,
+                           fixed_ips=[{'subnet_id': subnet['subnet']['id'],
+                                       'ip_address':
+                                       "2014::1322:33ff:fe44:5566"}]) as port:
+                # Check configuring of duplicate IP
+                kwargs = {"mac_address": "11:22:33:44:55:66"}
+                net_id = port['port']['network_id']
+                res = self._create_port(self.fmt, net_id=net_id, **kwargs)
+                self.assertEqual(res.status_int, webob.exc.HTTPConflict.code)
+
     def test_requested_subnet_id(self):
         with self.subnet() as subnet:
             with self.port(subnet=subnet) as port:
@@ -1785,8 +1849,8 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         ctx = context.get_admin_context()
         with self.subnet() as subnet:
             with contextlib.nested(
-                self.port(subnet=subnet, device_id='owner1'),
-                self.port(subnet=subnet, device_id='owner1'),
+                self.port(subnet=subnet, device_id='owner1', no_delete=True),
+                self.port(subnet=subnet, device_id='owner1', no_delete=True),
                 self.port(subnet=subnet, device_id='owner2'),
             ) as (p1, p2, p3):
                 network_id = subnet['subnet']['network_id']
@@ -1803,7 +1867,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
         ctx = context.get_admin_context()
         with self.subnet() as subnet:
             with contextlib.nested(
-                self.port(subnet=subnet, device_id='owner1'),
+                self.port(subnet=subnet, device_id='owner1', no_delete=True),
                 self.port(subnet=subnet, device_id='owner1'),
                 self.port(subnet=subnet, device_id='owner2'),
             ) as (p1, p2, p3):
@@ -2199,16 +2263,19 @@ class TestNetworksV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_sorting_helper',
             new=_fake_get_sorting_helper)
         helper_patcher.start()
-        with contextlib.nested(self.network(admin_status_up=True,
-                                            name='net1'),
-                               self.network(admin_status_up=False,
-                                            name='net2'),
-                               self.network(admin_status_up=False,
-                                            name='net3')
-                               ) as (net1, net2, net3):
-            self._test_list_with_sort('network', (net3, net2, net1),
-                                      [('admin_state_up', 'asc'),
-                                       ('name', 'desc')])
+        try:
+            with contextlib.nested(self.network(admin_status_up=True,
+                                                name='net1'),
+                                   self.network(admin_status_up=False,
+                                                name='net2'),
+                                   self.network(admin_status_up=False,
+                                                name='net3')
+                                   ) as (net1, net2, net3):
+                self._test_list_with_sort('network', (net3, net2, net1),
+                                          [('admin_state_up', 'asc'),
+                                           ('name', 'desc')])
+        finally:
+            helper_patcher.stop()
 
     def test_list_networks_with_pagination_native(self):
         if self._skip_native_pagination:
@@ -2226,31 +2293,37 @@ class TestNetworksV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        with contextlib.nested(self.network(name='net1'),
-                               self.network(name='net2'),
-                               self.network(name='net3')
-                               ) as (net1, net2, net3):
-            self._test_list_with_pagination('network',
-                                            (net1, net2, net3),
-                                            ('name', 'asc'), 2, 2)
+        try:
+            with contextlib.nested(self.network(name='net1'),
+                                   self.network(name='net2'),
+                                   self.network(name='net3')
+                                   ) as (net1, net2, net3):
+                self._test_list_with_pagination('network',
+                                                (net1, net2, net3),
+                                                ('name', 'asc'), 2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_list_networks_without_pk_in_fields_pagination_emulated(self):
         helper_patcher = mock.patch(
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        with contextlib.nested(self.network(name='net1',
-                                            shared=True),
-                               self.network(name='net2',
-                                            shared=False),
-                               self.network(name='net3',
-                                            shared=True)
-                               ) as (net1, net2, net3):
-            self._test_list_with_pagination('network',
-                                            (net1, net2, net3),
-                                            ('name', 'asc'), 2, 2,
-                                            query_params="fields=name",
-                                            verify_key='name')
+        try:
+            with contextlib.nested(self.network(name='net1',
+                                                shared=True),
+                                   self.network(name='net2',
+                                                shared=False),
+                                   self.network(name='net3',
+                                                shared=True)
+                                   ) as (net1, net2, net3):
+                self._test_list_with_pagination('network',
+                                                (net1, net2, net3),
+                                                ('name', 'asc'), 2, 2,
+                                                query_params="fields=name",
+                                                verify_key='name')
+        finally:
+            helper_patcher.stop()
 
     def test_list_networks_without_pk_in_fields_pagination_native(self):
         if self._skip_native_pagination:
@@ -2281,13 +2354,16 @@ class TestNetworksV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        with contextlib.nested(self.network(name='net1'),
-                               self.network(name='net2'),
-                               self.network(name='net3')
-                               ) as (net1, net2, net3):
-            self._test_list_with_pagination_reverse('network',
-                                                    (net1, net2, net3),
-                                                    ('name', 'asc'), 2, 2)
+        try:
+            with contextlib.nested(self.network(name='net1'),
+                                   self.network(name='net2'),
+                                   self.network(name='net3')
+                                   ) as (net1, net2, net3):
+                self._test_list_with_pagination_reverse('network',
+                                                        (net1, net2, net3),
+                                                        ('name', 'asc'), 2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_list_networks_with_parameters(self):
         with contextlib.nested(self.network(name='net1',
@@ -2667,8 +2743,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
         with self.network() as network:
             with contextlib.nested(
                 self.subnet(network=network),
-                self.subnet(network=network, cidr='10.0.1.0/24'),
-            ) as (subnet1, subnet2):
+                self.subnet(network=network, cidr='10.0.1.0/24',
+                            do_delete=False)) as (subnet1, subnet2):
                 subnet1_id = subnet1['subnet']['id']
                 subnet2_id = subnet2['subnet']['id']
                 with self.port(
@@ -2734,7 +2810,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
                                 set_context=True)
 
     def test_create_subnet_as_admin(self):
-        with self.network() as network:
+        with self.network(do_delete=False) as network:
             self._create_subnet(self.fmt,
                                 network['network']['id'],
                                 '10.0.2.0/24',
@@ -3220,6 +3296,16 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
             res = subnet_req.get_response(self.api)
             self.assertEqual(res.status_int, webob.exc.HTTPClientError.code)
 
+    def test_create_subnet_ipv6_attributes(self):
+        gateway_ip = 'fe80::1'
+        cidr = 'fe80::/80'
+
+        for mode in constants.IPV6_MODES:
+            self._test_create_subnet(gateway_ip=gateway_ip,
+                                     cidr=cidr, ip_version=6,
+                                     ipv6_ra_mode=mode,
+                                     ipv6_address_mode=mode)
+
     def _test_validate_subnet_ipv6_modes(self, cur_subnet=None,
                                          expect_success=True, **modes):
         plugin = manager.NeutronManager.get_plugin()
@@ -3325,6 +3411,31 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
         self.assertEqual(ctx_manager.exception.code,
                          webob.exc.HTTPClientError.code)
 
+    def test_create_subnet_invalid_ipv6_combination(self):
+        gateway_ip = 'fe80::1'
+        cidr = 'fe80::/80'
+        with testlib_api.ExpectedException(
+            webob.exc.HTTPClientError) as ctx_manager:
+            self._test_create_subnet(gateway_ip=gateway_ip,
+                                     cidr=cidr, ip_version=6,
+                                     ipv6_ra_mode='stateful',
+                                     ipv6_address_mode='stateless')
+        self.assertEqual(ctx_manager.exception.code,
+                         webob.exc.HTTPClientError.code)
+
+    def test_create_subnet_ipv6_single_attribute_set(self):
+        gateway_ip = 'fe80::1'
+        cidr = 'fe80::/80'
+        for mode in constants.IPV6_MODES:
+            self._test_create_subnet(gateway_ip=gateway_ip,
+                                     cidr=cidr, ip_version=6,
+                                     ipv6_ra_mode=None,
+                                     ipv6_address_mode=mode)
+            self._test_create_subnet(gateway_ip=gateway_ip,
+                                     cidr=cidr, ip_version=6,
+                                     ipv6_ra_mode=mode,
+                                     ipv6_address_mode=None)
+
     def test_create_subnet_ipv6_ra_mode_ip_version_4(self):
         cidr = '10.0.2.0/24'
         with testlib_api.ExpectedException(
@@ -3700,18 +3811,21 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_sorting_helper',
             new=_fake_get_sorting_helper)
         helper_patcher.start()
-        with contextlib.nested(self.subnet(enable_dhcp=True,
-                                           cidr='10.0.0.0/24'),
-                               self.subnet(enable_dhcp=False,
-                                           cidr='11.0.0.0/24'),
-                               self.subnet(enable_dhcp=False,
-                                           cidr='12.0.0.0/24')
-                               ) as (subnet1, subnet2, subnet3):
-            self._test_list_with_sort('subnet', (subnet3,
-                                                 subnet2,
-                                                 subnet1),
-                                      [('enable_dhcp', 'asc'),
-                                       ('cidr', 'desc')])
+        try:
+            with contextlib.nested(self.subnet(enable_dhcp=True,
+                                               cidr='10.0.0.0/24'),
+                                   self.subnet(enable_dhcp=False,
+                                               cidr='11.0.0.0/24'),
+                                   self.subnet(enable_dhcp=False,
+                                               cidr='12.0.0.0/24')
+                                   ) as (subnet1, subnet2, subnet3):
+                self._test_list_with_sort('subnet', (subnet3,
+                                                     subnet2,
+                                                     subnet1),
+                                          [('enable_dhcp', 'asc'),
+                                           ('cidr', 'desc')])
+        finally:
+            helper_patcher.stop()
 
     def test_list_subnets_with_pagination_native(self):
         if self._skip_native_pagination:
@@ -3729,13 +3843,16 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        with contextlib.nested(self.subnet(cidr='10.0.0.0/24'),
-                               self.subnet(cidr='11.0.0.0/24'),
-                               self.subnet(cidr='12.0.0.0/24')
-                               ) as (subnet1, subnet2, subnet3):
-            self._test_list_with_pagination('subnet',
-                                            (subnet1, subnet2, subnet3),
-                                            ('cidr', 'asc'), 2, 2)
+        try:
+            with contextlib.nested(self.subnet(cidr='10.0.0.0/24'),
+                                   self.subnet(cidr='11.0.0.0/24'),
+                                   self.subnet(cidr='12.0.0.0/24')
+                                   ) as (subnet1, subnet2, subnet3):
+                self._test_list_with_pagination('subnet',
+                                                (subnet1, subnet2, subnet3),
+                                                ('cidr', 'asc'), 2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_list_subnets_with_pagination_reverse_native(self):
         if self._skip_native_sorting:
@@ -3754,14 +3871,17 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
             'neutron.api.v2.base.Controller._get_pagination_helper',
             new=_fake_get_pagination_helper)
         helper_patcher.start()
-        with contextlib.nested(self.subnet(cidr='10.0.0.0/24'),
-                               self.subnet(cidr='11.0.0.0/24'),
-                               self.subnet(cidr='12.0.0.0/24')
-                               ) as (subnet1, subnet2, subnet3):
-            self._test_list_with_pagination_reverse('subnet',
-                                                    (subnet1, subnet2,
-                                                     subnet3),
-                                                    ('cidr', 'asc'), 2, 2)
+        try:
+            with contextlib.nested(self.subnet(cidr='10.0.0.0/24'),
+                                   self.subnet(cidr='11.0.0.0/24'),
+                                   self.subnet(cidr='12.0.0.0/24')
+                                   ) as (subnet1, subnet2, subnet3):
+                self._test_list_with_pagination_reverse('subnet',
+                                                        (subnet1, subnet2,
+                                                         subnet3),
+                                                        ('cidr', 'asc'), 2, 2)
+        finally:
+            helper_patcher.stop()
 
     def test_invalid_ip_version(self):
         with self.network() as network:
@@ -4074,9 +4194,9 @@ class TestNeutronDbPluginV2(base.BaseTestCase):
     """Unit Tests for NeutronDbPluginV2 IPAM Logic."""
 
     def test_generate_ip(self):
-        with mock.patch.object(db_base_plugin_v2.NeutronDbPluginV2,
+        with mock.patch.object(db_base_plugin_v2.NeutronCorePluginV2,
                                '_try_generate_ip') as generate:
-            with mock.patch.object(db_base_plugin_v2.NeutronDbPluginV2,
+            with mock.patch.object(db_base_plugin_v2.NeutronCorePluginV2,
                                    '_rebuild_availability_ranges') as rebuild:
 
                 db_base_plugin_v2.NeutronDbPluginV2._generate_ip('c', 's')
@@ -4085,15 +4205,22 @@ class TestNeutronDbPluginV2(base.BaseTestCase):
         self.assertEqual(0, rebuild.call_count)
 
     def test_generate_ip_exhausted_pool(self):
-        with mock.patch.object(db_base_plugin_v2.NeutronDbPluginV2,
+        with mock.patch.object(db_base_plugin_v2.NeutronCorePluginV2,
                                '_try_generate_ip') as generate:
-            with mock.patch.object(db_base_plugin_v2.NeutronDbPluginV2,
+            with mock.patch.object(db_base_plugin_v2.NeutronCorePluginV2,
                                    '_rebuild_availability_ranges') as rebuild:
 
                 exception = n_exc.IpAddressGenerationFailure(net_id='n')
-                # fail first call but not second
-                generate.side_effect = [exception, None]
-                db_base_plugin_v2.NeutronDbPluginV2._generate_ip('c', 's')
+                generate.side_effect = exception
+
+                # I want the side_effect to throw an exception once but I
+                # didn't see a way to do this.  So, let it throw twice and
+                # catch the second one.  Check below to ensure that
+                # _try_generate_ip was called twice.
+                try:
+                    db_base_plugin_v2.NeutronDbPluginV2._generate_ip('c', 's')
+                except n_exc.IpAddressGenerationFailure:
+                    pass
 
         self.assertEqual(2, generate.call_count)
         rebuild.assert_called_once_with('c', 's')
@@ -4236,6 +4363,12 @@ class NeutronDbPluginV2AsMixinTestCase(testlib_api.SqlTestCase):
 
     def setUp(self):
         super(NeutronDbPluginV2AsMixinTestCase, self).setUp()
+
+        mock_nm_get_ipam = mock.patch(
+            'neutron.manager.NeutronManager.get_ipam')
+        self.mock_nm_get_ipam = mock_nm_get_ipam.start()
+        self.mock_nm_get_ipam.return_value = neutron_ipam.NeutronIPAM()
+
         self.plugin = importutils.import_object(DB_PLUGIN_KLASS)
         self.context = context.get_admin_context()
         self.net_data = {'network': {'id': 'fake-id',
@@ -4244,6 +4377,9 @@ class NeutronDbPluginV2AsMixinTestCase(testlib_api.SqlTestCase):
                                      'tenant_id': 'test-tenant',
                                      'shared': False}}
 
+        self.addCleanup(mock_nm_get_ipam.stop)
+        self.addCleanup(db.clear_db)
+
     def test_create_network_with_default_status(self):
         net = self.plugin.create_network(self.context, self.net_data)
         default_net_create_status = 'ACTIVE'
diff --git a/neutron/tests/unit/test_linux_dhcp_relay.py b/neutron/tests/unit/test_linux_dhcp_relay.py
new file mode 100644
index 0000000..8e24ae5
--- /dev/null
+++ b/neutron/tests/unit/test_linux_dhcp_relay.py
@@ -0,0 +1,537 @@
+# Copyright 2014 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import __builtin__
+import os
+
+import mock
+
+from neutron.agent.common import config
+from neutron.agent.linux import dhcp
+from neutron.agent.linux import dhcp_relay
+from neutron.agent.linux import interface
+from neutron.agent.linux import utils
+from neutron.common import config as base_config
+from neutron.common import exceptions as exc
+from neutron.tests import base
+
+
+DHCP_RELAY_IP = '192.168.122.32'
+DNS_RELAY_IP = '192.168.122.32'
+
+
+class FakeDeviceManager():
+    def __init__(self, conf, root_helper, plugin):
+        pass
+
+    def get_interface_name(self, network, port):
+        pass
+
+    def get_device_id(self, network):
+        pass
+
+    def setup_dhcp_port(self, network):
+        pass
+
+    def setup(self, network, reuse_existing=False):
+        pass
+
+    def update(self, network):
+        pass
+
+    def destroy(self, network, device_name):
+        pass
+
+    def setup_relay(self, network, iface_name, mac_address, relay_bridge):
+        pass
+
+    def destroy_relay(self, network, device_name, relay_bridge):
+        pass
+
+
+class FakeIPAllocation:
+    def __init__(self, address):
+        self.ip_address = address
+
+
+class FakePort1:
+    id = 'eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee'
+    admin_state_up = True
+    fixed_ips = [FakeIPAllocation('192.168.0.2')]
+    mac_address = '00:00:80:aa:bb:cc'
+
+    def __init__(self):
+        self.extra_dhcp_opts = []
+
+
+class FakeV4HostRoute:
+    destination = '20.0.0.1/24'
+    nexthop = '20.0.0.1'
+
+
+class FakeV4Subnet:
+    id = 'dddddddd-dddd-dddd-dddd-dddddddddddd'
+    ip_version = 4
+    cidr = '192.168.0.0/24'
+    gateway_ip = '192.168.0.1'
+    enable_dhcp = True
+    host_routes = [FakeV4HostRoute]
+    dns_nameservers = ['8.8.8.8']
+
+
+class FakeV4Network:
+    id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+    tenant_id = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+    subnets = [FakeV4Subnet()]
+    ports = [FakePort1()]
+    namespace = 'qdhcp-ns'
+    dhcp_relay_ip = DHCP_RELAY_IP
+    dns_relay_ip = DNS_RELAY_IP
+
+
+class FakeOpen():
+    def __init__(self, *args):
+        pass
+
+    def read(self):
+        return 'dhcrelay -a -i tap77777777-77 %s' % DHCP_RELAY_IP
+
+
+class TestBase(base.BaseTestCase):
+    def setUp(self):
+        super(TestBase, self).setUp()
+        self.network = FakeV4Network()
+        root = os.path.dirname(os.path.dirname(__file__))
+        args = ['--config-file',
+                os.path.join(root, 'etc', 'neutron.conf.test')]
+        self.conf = config.setup_conf()
+        self.conf.register_opts(base_config.core_opts)
+        self.conf.register_opts(dhcp.OPTS)
+        self.conf.register_opts(dhcp_relay.OPTS)
+        self.conf.register_opts(interface.OPTS)
+
+        def dhcp_dns_proxy_init_mock(self, conf, network, root_helper='sudo',
+                                     version=None, plugin=None):
+            super(dhcp_relay.DhcpDnsProxy, self).__init__(
+                conf, network,
+                root_helper,
+                version, plugin)
+
+            external_dhcp_servers = self._get_relay_ips(
+                'external_dhcp_servers')
+            external_dns_servers = self._get_relay_ips('external_dns_servers')
+            required_options = {
+                'dhcp_relay_bridge': self.conf.dhcp_relay_bridge,
+                'external_dhcp_servers': external_dhcp_servers,
+                'external_dns_servers': external_dns_servers
+            }
+
+            for option_name, option in required_options.iteritems():
+                if not option:
+                    raise exc.InvalidConfigurationOption(
+                        opt_name=option_name,
+                        opt_value=option
+                    )
+
+            self.dev_name_len = self._calc_dev_name_len()
+            self.device_manager = mock.Mock()
+
+        dhcp_dns_proxy_mock = mock.patch(
+            "neutron.agent.linux.dhcp_relay.DhcpDnsProxy.__init__",
+            dhcp_dns_proxy_init_mock
+        )
+        dhcp_dns_proxy_mock.start()
+
+        device_manager_init = mock.patch(
+            "neutron.agent.linux.dhcp.DeviceManager.__init__",
+            lambda *args, **kwargs: None)
+        device_manager_init.start()
+
+        self.conf(args=args)
+        self.conf.set_override('state_path', '')
+        self.conf.dhcp_relay_bridge = 'br-dhcp'
+
+        self.replace_p = mock.patch('neutron.agent.linux.utils.replace_file')
+        self.execute_p = mock.patch('neutron.agent.linux.utils.execute')
+        self.addCleanup(self.replace_p.stop)
+        self.addCleanup(self.execute_p.stop)
+        self.safe = self.replace_p.start()
+        self.execute = self.execute_p.start()
+
+    def get_fixed_ddi_proxy(self):
+        def _get_relay_ips(self, data):
+            return ['192.168.122.32']
+
+        attrs_to_mock = {
+            '_get_relay_ips': _get_relay_ips
+        }
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock):
+            return dhcp_relay.DhcpDnsProxy
+
+
+class TestDnsDhcpProxy(TestBase):
+
+    def test_create_instance_no_dhcp_relay_server(self):
+        self.conf.dhcp_relay_ip = None
+        self.network.dhcp_relay_ip = None
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy,
+                          self.conf,
+                          self.network)
+
+    def test_create_instance_bad_dhcp_relay_server(self):
+        self.conf.dhcp_relay_ip = '192.168.122.322'
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy,
+                          self.conf,
+                          self.network)
+
+    def test_create_instance_no_dns_relay_server(self):
+        self.conf.dns_relay_ip = None
+        self.network.dhcp_relay_ip = None
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy,
+                          self.conf,
+                          self.network)
+
+    def test_create_instance_bad_dns_relay_server(self):
+        self.conf.dns_relay_ip = '192.168.122.322'
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy,
+                          self.conf,
+                          self.network)
+
+    def test_create_instance_no_relay_bridge(self):
+        self.conf.dhcp_relay_bridge = None
+        self.assertRaises(exc.InvalidConfigurationOption,
+                          dhcp_relay.DhcpDnsProxy,
+                          self.conf,
+                          self.network)
+
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, "_spawn_dhcp_proxy")
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, "_spawn_dns_proxy")
+    def test_spawn(self, mock_spawn_dns, mock_spawn_dhcp):
+        attrs_to_mock = {
+            '_get_relay_ips': mock.Mock(return_value=['192.168.122.32'])
+        }
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock):
+            dm = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dm.spawn_process()
+
+            mock_spawn_dns.assert_called_once_with()
+            mock_spawn_dhcp.assert_called_once_with()
+
+    @mock.patch.object(dhcp.DhcpLocalProcess, 'get_conf_file_name')
+    def test__spawn_dhcp_proxy(self, get_conf_file_name_mock):
+        test_dns_conf_path = 'test_dir/dhcp/test_dns_pid'
+        get_conf_file_name_mock.return_value = test_dns_conf_path
+
+        expected = [
+            'ip',
+            'netns',
+            'exec',
+            'qdhcp-ns',
+            'dhcrelay',
+            '-4',
+            '-a',
+            '-pf',
+            test_dns_conf_path,
+            '-i',
+            'tap0',
+            '-o',
+            'trelaaaaaaaa-a',
+            self.network.dhcp_relay_ip
+        ]
+
+        self.execute.return_value = ('', '')
+
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+            ['interface_name', '_get_relay_ips']]
+        )
+
+        attrs_to_mock.update({
+            '_get_relay_ips': mock.Mock(return_value=['192.168.122.32'])
+        })
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            mocks['interface_name'].__get__ = mock.Mock(return_value='tap0')
+
+            dm = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dm._spawn_dhcp_proxy()
+            self.execute.assert_called_once_with(expected,
+                                                 root_helper='sudo',
+                                                 check_exit_code=True)
+
+    @mock.patch.object(dhcp.DhcpLocalProcess, 'get_conf_file_name')
+    def test__spawn_dhcp_proxy_no_namespace(self, get_conf_file_name_mock):
+        test_dns_conf_path = 'test_dir/dhcp/test_dns_pid'
+        get_conf_file_name_mock.return_value = test_dns_conf_path
+        self.network.namespace = None
+
+        expected = [
+            'dhcrelay',
+            '-4',
+            '-a',
+            '-pf',
+            test_dns_conf_path,
+            '-i',
+            'tap0',
+            '-o',
+            'trelaaaaaaaa-a',
+            self.network.dhcp_relay_ip
+        ]
+
+        self.execute.return_value = ('', '')
+
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+            ['interface_name', '_get_relay_ips']]
+        )
+
+        attrs_to_mock.update({
+            '_get_relay_ips': mock.Mock(return_value=['192.168.122.32'])
+        })
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            mocks['interface_name'].__get__ = mock.Mock(return_value='tap0')
+
+            dm = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dm._spawn_dhcp_proxy()
+            self.execute.assert_called_once_with(expected, 'sudo')
+
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, 'interface_name')
+    @mock.patch.object(dhcp.DhcpLocalProcess, 'get_conf_file_name')
+    def test__spawn_dns_proxy(self, get_conf_file_name_mock, iface_name_mock):
+        test_dns_conf_path = 'test_dir/dhcp/test_dns_pid'
+        get_conf_file_name_mock.return_value = test_dns_conf_path
+        iface_name_mock.__get__ = mock.Mock(return_value='test_tap0')
+        expected = [
+            'ip',
+            'netns',
+            'exec',
+            'qdhcp-ns',
+            'dnsmasq',
+            '--no-hosts',
+            '--no-resolv',
+            '--strict-order',
+            '--bind-interfaces',
+            '--interface=test_tap0',
+            '--except-interface=lo',
+            '--all-servers',
+            '--server=%s' % self.network.dns_relay_ip,
+            '--pid-file=%s' % test_dns_conf_path
+        ]
+        self.execute.return_value = ('', '')
+
+        attrs_to_mock = {
+            '_get_relay_ips': mock.Mock(return_value=['192.168.122.32'])
+        }
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock):
+
+            dm = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dm._spawn_dns_proxy()
+
+            self.execute.assert_called_once_with(expected,
+                                                 root_helper='sudo',
+                                                 check_exit_code=True)
+
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, 'interface_name')
+    @mock.patch.object(dhcp.DhcpLocalProcess, 'get_conf_file_name')
+    def test__spawn_dns_proxy_no_namespace(self, get_conf_file_name_mock,
+                                           iface_name_mock):
+        self.network.namespace = None
+        test_dns_conf_path = 'test_dir/dhcp/test_dns_pid'
+        get_conf_file_name_mock.return_value = test_dns_conf_path
+        iface_name_mock.__get__ = mock.Mock(return_value='test_tap0')
+        expected = [
+            'dnsmasq',
+            '--no-hosts',
+            '--no-resolv',
+            '--strict-order',
+            '--bind-interfaces',
+            '--interface=test_tap0',
+            '--except-interface=lo',
+            '--all-servers',
+            '--server=%s' % self.network.dns_relay_ip,
+            '--pid-file=%s' % test_dns_conf_path
+        ]
+        self.execute.return_value = ('', '')
+
+        attrs_to_mock = {
+            '_get_relay_ips': mock.Mock(return_value=['192.168.122.32'])}
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock):
+            dm = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dm._spawn_dns_proxy()
+
+            self.execute.assert_called_once_with(expected, 'sudo')
+
+    @mock.patch.object(dhcp_relay, '_generate_mac_address',
+                       mock.Mock(return_value='77:77:77:77:77:77'))
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, '_get_relay_device_name',
+                       mock.Mock(return_value='tap-relay77777'))
+    @mock.patch.object(FakeDeviceManager, 'setup',
+                       mock.Mock(return_value='tap-77777777'))
+    @mock.patch.object(FakeDeviceManager, 'setup_relay', mock.Mock())
+    def test_enable_dhcp_dns_inactive(self):
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+             ['interface_name', '_get_relay_ips', 'restart',
+              'is_dhcp_active', 'is_dns_active', 'spawn_process']]
+        )
+
+        attrs_to_mock.update(
+            {'_get_relay_ips': mock.Mock(return_value=['192.168.122.32']),
+             'is_dhcp_active': mock.Mock(return_value=True),
+             'is_dns_active': mock.Mock(return_value=True),
+             'spawn_process': mock.Mock(return_value=None)}
+        )
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            mocks['interface_name'].__set__ = mock.Mock()
+
+            dr = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dr.enable()
+
+            dr.device_manager.setup_relay.assert_called_once_with(
+                self.network,
+                'tap-relay77777',
+                '77:77:77:77:77:77',
+                self.conf.dhcp_relay_bridge)
+            dr.device_manager.setup.assert_called_once_with(
+                self.network,
+                reuse_existing=True)
+
+    @mock.patch.object(dhcp_relay, '_generate_mac_address',
+                       mock.Mock(return_value='77:77:77:77:77:77'))
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, '_get_relay_device_name',
+                       mock.Mock(return_value='tap-relay77777'))
+    @mock.patch.object(FakeDeviceManager, 'setup',
+                       mock.Mock(return_value='tap-77777777'))
+    @mock.patch.object(FakeDeviceManager, 'setup_relay', mock.Mock())
+    def test_enable_dhcp_dns_active(self):
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+            ['interface_name', 'is_dhcp_active', 'is_dns_active', 'restart',
+             '_get_relay_ips']]
+        )
+
+        attrs_to_mock.update(
+            {'_get_relay_ips': mock.Mock(return_value=['192.168.122.32']),
+             'is_dhcp_active': mock.Mock(return_value=True),
+             'is_dns_active': mock.Mock(return_value=True)}
+        )
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            mocks['interface_name'].__set__ = mock.Mock()
+
+            dr = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dr.enable()
+
+            dr.device_manager.setup_relay.assert_called_once_with(
+                self.network,
+                'tap-relay77777',
+                '77:77:77:77:77:77',
+                self.conf.dhcp_relay_bridge)
+            dr.device_manager.setup.assert_called_once_with(
+                self.network,
+                reuse_existing=True)
+            mocks['restart'].assert_any_call()
+
+    def test_disable_retain_port(self):
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+            ['is_dhcp_active', 'is_dns_active', 'get_dhcp_pid', 'get_dns_pid',
+             'restart', '_remove_config_files']]
+        )
+
+        attrs_to_mock.update(
+            {'_get_relay_ips': mock.Mock(return_value=['192.168.122.32']),
+             'is_dhcp_active': mock.Mock(return_value=True),
+             'is_dns_active': mock.Mock(return_value=True),
+             'get_dhcp_pid': mock.Mock(return_value='1111'),
+             'get_dns_pid': mock.Mock(return_value='2222')}
+        )
+
+        kill_proc_calls = [
+            mock.call(['kill', '-9', '1111'], 'sudo'),
+            mock.call(['kill', '-9', '2222'], 'sudo')]
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            dr = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dr.disable(retain_port=True)
+
+            self.execute.assert_has_calls(kill_proc_calls)
+            mocks['_remove_config_files'].assert_any_call()
+
+    @mock.patch.object(dhcp_relay.DhcpDnsProxy, '_get_relay_device_name',
+                       mock.Mock(return_value='tap-relay77777'))
+    @mock.patch.object(FakeDeviceManager, 'destroy', mock.Mock())
+    @mock.patch.object(FakeDeviceManager, 'destroy_relay', mock.Mock())
+    def test_disable_no_retain_port(self):
+        attrs_to_mock = dict(
+            [(a, mock.DEFAULT) for a in
+            ['is_dhcp_active', 'is_dns_active', 'get_dhcp_pid',
+             'get_dhcp_pid', 'interface_name', '_remove_config_files']]
+        )
+
+        attrs_to_mock.update(
+            {'_get_relay_ips': mock.Mock(return_value=['192.168.122.32']),
+             'is_dhcp_active': mock.Mock(return_value=True),
+             'is_dns_active': mock.Mock(return_value=True),
+             'get_dhcp_pid': mock.Mock(return_value='1111'),
+             'get_dns_pid': mock.Mock(return_value='2222')}
+        )
+
+        kill_proc_calls = [
+            mock.call(['kill', '-9', '1111'], 'sudo'),
+            mock.call(['kill', '-9', '2222'], 'sudo')]
+
+        with mock.patch.multiple(dhcp_relay.DhcpDnsProxy,
+                                 **attrs_to_mock) as mocks:
+            mocks['interface_name'].__get__ = mock.Mock(
+                return_value='tap-77777777')
+
+            dr = dhcp_relay.DhcpDnsProxy(self.conf, self.network)
+            dr.disable(retain_port=False)
+
+            self.execute.assert_has_calls(kill_proc_calls)
+            dr.device_manager.destroy.assert_called_once_with(self.network,
+                                                              'tap-77777777')
+            dr.device_manager.destroy_relay.assert_called_once_with(
+                self.network,
+                'tap-relay77777',
+                self.conf.dhcp_relay_bridge)
+
+            mocks['_remove_config_files'].assert_any_call()
+
+    def test_generate_mac(self):
+        mac = dhcp_relay._generate_mac_address()
+        mac_array = mac.split(':')
+        self.assertEqual(6, len(mac_array))
+        for item in mac_array:
+            self.assertEqual(2, len(item))
diff --git a/neutron/tests/unit/vmware/test_nsx_sync.py b/neutron/tests/unit/vmware/test_nsx_sync.py
index cacfc24..ff8e6bf 100644
--- a/neutron/tests/unit/vmware/test_nsx_sync.py
+++ b/neutron/tests/unit/vmware/test_nsx_sync.py
@@ -304,6 +304,22 @@ class SyncTestCase(testlib_api.SqlTestCase):
         super(SyncTestCase, self).setUp()
         self.addCleanup(self.fc.reset_all)
 
+        mock_nm_get_ipam = mock.patch('neutron.manager.NeutronManager.'
+                                      'get_ipam')
+        self.mock_nm_get_ipam = mock_nm_get_ipam.start()
+        ipam = mock.Mock()
+        ipam.create_network = lambda ctx, net: net
+
+        self.allocate_counter = 1
+        ipam.allocate_ip = self._allocate_ip_mock
+
+        self.mock_nm_get_ipam.return_value = ipam
+        self.addCleanup(mock_nm_get_ipam.stop)
+
+    def _allocate_ip_mock(self, *args):
+        self.allocate_counter += 1
+        return '10.20.30.%s' % self.allocate_counter
+
     @contextlib.contextmanager
     def _populate_data(self, ctx, net_size=2, port_size=2, router_size=2):
 
diff --git a/requirements.txt b/requirements.txt
index 9ab21f6..49ab3b2 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -31,3 +31,5 @@ oslo.messaging<1.5.0,>=1.4.0
 oslo.rootwrap<=1.5.0,>=1.3.0
 
 python-novaclient<=2.20.0,>=2.18.0
+
+taskflow>=0.1.3,<=0.3.21
diff --git a/test-requirements.txt b/test-requirements.txt
index 04d0e59..9536425 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -16,3 +16,4 @@ oslosphinx<2.5.0,>=2.2.0 # Apache-2.0
 testrepository<=0.0.20,>=0.0.18
 testtools!=1.4.0,<=1.5.0,>=0.9.34
 WebTest<=2.0.18,>=2.0
+taskflow
