Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
Cloud:OpenStack:Juno:Staging
openstack-neutron
infoblox-ipam-juno.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File infoblox-ipam-juno.patch of Package openstack-neutron
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
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
