openstack
/
neutron
Code Issues Proposed changes

Fix deprecation warnings 

Remove deprecation warnings for various constants
and exceptions that have moved to neutron_lib.

Fix miscellaneous other deprecations.

Uses constants instead of l3_constants when importing
neutron-lib constants.

Co-Authored By: Henry Gessau <gessau@gmail.com>
Co-Authored By: Gary Kotton <gkotton@vmware.com>

Change-Id: Ib0e8ff5c3e23677c1009241a1818cbc8a3430c38
This commit is contained in:
Gary Kotton 2016-08-12 07:06:50 -07:00 committed by Henry Gessau
parent d30610c8da
commit 9f09f27c5d
69 changed files with 492 additions and 526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
neutron/agent/l3/agent.py
View File

@ -372,7 +372,7 @@ class L3NATAgent(ha.AgentMixin,
self.l3_ext_manager = (
l3_ext_manager.L3AgentExtensionsManager(self.conf))
self.l3_ext_manager.initialize(
connection, l3_constants.L3_AGENT_MODE)
connection, lib_const.L3_AGENT_MODE)
def router_deleted(self, context, router_id):
"""Deal with router deletion RPC message."""
@ -560,7 +560,7 @@ class L3NATAgent(ha.AgentMixin,
ext_net_id = (r['external_gateway_info'] or {}).get(
'network_id')
is_snat_agent = (self.conf.agent_mode ==
l3_constants.L3_AGENT_MODE_DVR_SNAT)
lib_const.L3_AGENT_MODE_DVR_SNAT)
if ext_net_id:
ns_manager.keep_ext_net(ext_net_id)
elif is_snat_agent:

3
neutron/agent/l3/dvr_edge_ha_router.py
View File

@ -19,7 +19,6 @@ from neutron.agent.l3 import dvr_edge_router
from neutron.agent.l3 import dvr_snat_ns
from neutron.agent.l3 import ha_router
from neutron.agent.l3 import router_info
from neutron.common import constants as l3_constants
class DvrEdgeHaRouter(dvr_edge_router.DvrEdgeRouter,
@ -105,7 +104,7 @@ class DvrEdgeHaRouter(dvr_edge_router.DvrEdgeRouter,
def _is_this_snat_host(self):
return (self.agent_conf.agent_mode
== l3_constants.L3_AGENT_MODE_DVR_SNAT)
== constants.L3_AGENT_MODE_DVR_SNAT)
def _dvr_internal_network_removed(self, port):
super(DvrEdgeHaRouter, self)._dvr_internal_network_removed(port)

6
neutron/agent/l3/dvr_edge_router.py
View File

@ -12,7 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_log import log as logging
from neutron._i18n import _LE
@ -235,8 +235,8 @@ class DvrEdgeRouter(dvr_local_router.DvrLocalRouter):
if external_port:
external_port_scopemark = self._get_port_devicename_scopemark(
[external_port], self.get_external_device_name)
for ip_version in (l3_constants.IP_VERSION_4,
l3_constants.IP_VERSION_6):
for ip_version in (lib_constants.IP_VERSION_4,
lib_constants.IP_VERSION_6):
ports_scopemark[ip_version].update(
external_port_scopemark[ip_version])

18
neutron/agent/l3/dvr_local_router.py
View File

@ -16,7 +16,8 @@ import binascii
import collections
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions
from oslo_log import log as logging
from oslo_utils import excutils
import six
@ -26,7 +27,6 @@ from neutron.agent.l3 import dvr_fip_ns
from neutron.agent.l3 import dvr_router_base
from neutron.agent.linux import ip_lib
from neutron.common import constants as n_const
from neutron.common import exceptions
from neutron.common import utils as common_utils
LOG = logging.getLogger(__name__)
@ -163,18 +163,18 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase):
# Special Handling for DVR - update FIP namespace
ip_cidr = common_utils.ip_to_cidr(fip['floating_ip_address'])
self.floating_ip_added_dist(fip, ip_cidr)
return l3_constants.FLOATINGIP_STATUS_ACTIVE
return lib_constants.FLOATINGIP_STATUS_ACTIVE
def remove_floating_ip(self, device, ip_cidr):
self.floating_ip_removed_dist(ip_cidr)
def move_floating_ip(self, fip):
self.floating_ip_moved_dist(fip)
return l3_constants.FLOATINGIP_STATUS_ACTIVE
return lib_constants.FLOATINGIP_STATUS_ACTIVE
def _get_internal_port(self, subnet_id):
"""Return internal router port based on subnet_id."""
router_ports = self.router.get(l3_constants.INTERFACE_KEY, [])
router_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
for port in router_ports:
fips = port['fixed_ips']
for f in fips:
@ -252,7 +252,7 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase):
subnet_ports = self.agent.get_ports_by_subnet(subnet_id)
for p in subnet_ports:
if p['device_owner'] not in l3_constants.ROUTER_INTERFACE_OWNERS:
if p['device_owner'] not in lib_constants.ROUTER_INTERFACE_OWNERS:
for fixed_ip in p['fixed_ips']:
self._update_arp_entry(fixed_ip['ip_address'],
p['mac_address'],
@ -460,7 +460,7 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase):
def _get_address_scope_mark(self):
# Prepare address scope iptables rule for internal ports
internal_ports = self.router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
ports_scopemark = self._get_port_devicename_scopemark(
internal_ports, self.get_internal_device_name)
# DVR local router will use rfp port as external port
@ -474,7 +474,7 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase):
ext_scope = self._get_external_address_scope()
ext_scope_mark = self.get_address_scope_mark_mask(ext_scope)
ports_scopemark[l3_constants.IP_VERSION_4][ext_device_name] = (
ports_scopemark[lib_constants.IP_VERSION_4][ext_device_name] = (
ext_scope_mark)
return ports_scopemark
@ -536,7 +536,7 @@ class DvrLocalRouter(dvr_router_base.DvrRouterBase):
self.router_id)
rtr_2_fip, _fip_2_rtr = self.rtr_fip_subnet.get_pair()
exist_routes = device.route.list_routes(
l3_constants.IP_VERSION_4, via=str(rtr_2_fip.ip))
lib_constants.IP_VERSION_4, via=str(rtr_2_fip.ip))
return {common_utils.ip_to_cidr(route['cidr'])
for route in exist_routes}

2
neutron/agent/l3/dvr_snat_ns.py
View File

@ -10,11 +10,11 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron_lib import constants
from oslo_log import log as logging
from neutron.agent.l3 import namespaces
from neutron.agent.linux import ip_lib
from neutron.common import constants
LOG = logging.getLogger(__name__)
SNAT_NS_PREFIX = 'snat-'

6
neutron/agent/l3/legacy_router.py
View File

@ -12,7 +12,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron.agent.l3 import router_info as router
from neutron.agent.linux import ip_lib
@ -21,7 +21,7 @@ from neutron.agent.linux import ip_lib
class LegacyRouter(router.RouterInfo):
def add_floating_ip(self, fip, interface_name, device):
if not self._add_fip_addr_to_device(fip, device):
return l3_constants.FLOATINGIP_STATUS_ERROR
return lib_constants.FLOATINGIP_STATUS_ERROR
# As GARP is processed in a distinct thread the call below
# won't raise an exception to be handled.
@ -29,4 +29,4 @@ class LegacyRouter(router.RouterInfo):
interface_name,
fip['floating_ip_address'],
self.agent_conf)
return l3_constants.FLOATINGIP_STATUS_ACTIVE
return lib_constants.FLOATINGIP_STATUS_ACTIVE

46
neutron/agent/l3/router_info.py
View File

@ -14,7 +14,7 @@
import collections
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_log import log as logging
from neutron._i18n import _, _LE, _LW
@ -143,7 +143,7 @@ class RouterInfo(object):
def get_floating_ips(self):
"""Filter Floating IPs to be hosted on this agent."""
return self.router.get(l3_constants.FLOATINGIP_KEY, [])
return self.router.get(lib_constants.FLOATINGIP_KEY, [])
def floating_forward_rules(self, floating_ip, fixed_ip):
return [('PREROUTING', '-d %s/32 -j DNAT --to-destination %s' %
@ -226,7 +226,7 @@ class RouterInfo(object):
ports_scopemark = self._get_address_scope_mark()
devices_in_ext_scope = {
device for device, mark
in ports_scopemark[l3_constants.IP_VERSION_4].items()
in ports_scopemark[lib_constants.IP_VERSION_4].items()
if mark == ext_scope_mark}
# Add address scope for floatingip egress
for device in devices_in_ext_scope:
@ -279,7 +279,7 @@ class RouterInfo(object):
device.delete_addr_and_conntrack_state(ip_cidr)
def move_floating_ip(self, fip):
return l3_constants.FLOATINGIP_STATUS_ACTIVE
return lib_constants.FLOATINGIP_STATUS_ACTIVE
def remove_external_gateway_ip(self, device, ip_cidr):
device.delete_addr_and_conntrack_state(ip_cidr)
@ -311,7 +311,7 @@ class RouterInfo(object):
fip_ip = fip['floating_ip_address']
ip_cidr = common_utils.ip_to_cidr(fip_ip)
new_cidrs.add(ip_cidr)
fip_statuses[fip['id']] = l3_constants.FLOATINGIP_STATUS_ACTIVE
fip_statuses[fip['id']] = lib_constants.FLOATINGIP_STATUS_ACTIVE
if ip_cidr not in existing_cidrs:
fip_statuses[fip['id']] = self.add_floating_ip(
fip, interface_name, device)
@ -346,7 +346,7 @@ class RouterInfo(object):
for ip_addr in ex_gw_port['fixed_ips']:
ex_gw_ip = ip_addr['ip_address']
addr = netaddr.IPAddress(ex_gw_ip)
if addr.version == l3_constants.IP_VERSION_4:
if addr.version == lib_constants.IP_VERSION_4:
gw_cidrs.add(common_utils.ip_to_cidr(ex_gw_ip))
return gw_cidrs
@ -361,14 +361,14 @@ class RouterInfo(object):
def put_fips_in_error_state(self):
fip_statuses = {}
for fip in self.router.get(l3_constants.FLOATINGIP_KEY, []):
fip_statuses[fip['id']] = l3_constants.FLOATINGIP_STATUS_ERROR
for fip in self.router.get(lib_constants.FLOATINGIP_KEY, []):
fip_statuses[fip['id']] = lib_constants.FLOATINGIP_STATUS_ERROR
return fip_statuses
def delete(self, agent):
self.router['gw_port'] = None
self.router[l3_constants.INTERFACE_KEY] = []
self.router[l3_constants.FLOATINGIP_KEY] = []
self.router[lib_constants.INTERFACE_KEY] = []
self.router[lib_constants.FLOATINGIP_KEY] = []
self.process_delete(agent)
self.disable_radvd()
self.router_namespace.delete()
@ -487,7 +487,7 @@ class RouterInfo(object):
def _process_internal_ports(self, pd):
existing_port_ids = set(p['id'] for p in self.internal_ports)
internal_ports = self.router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
current_port_ids = set(p['id'] for p in internal_ports
if p['admin_state_up'])
@ -643,8 +643,8 @@ class RouterInfo(object):
device = ip_lib.IPDevice(interface_name, namespace=ns_name)
current_gateways = set()
for ip_version in (l3_constants.IP_VERSION_4,
l3_constants.IP_VERSION_6):
for ip_version in (lib_constants.IP_VERSION_4,
lib_constants.IP_VERSION_6):
gateway = device.route.get_gateway(ip_version=ip_version)
if gateway and gateway.get('gateway'):
current_gateways.add(gateway.get('gateway'))
@ -856,7 +856,7 @@ class RouterInfo(object):
existing_floating_ips = self.floating_ips
self.floating_ips = set(fip_statuses.keys())
for fip_id in existing_floating_ips - self.floating_ips:
fip_statuses[fip_id] = l3_constants.FLOATINGIP_STATUS_DOWN
fip_statuses[fip_id] = lib_constants.FLOATINGIP_STATUS_DOWN
# filter out statuses that didn't change
fip_statuses = {f: stat for f, stat in fip_statuses.items()
if stat != FLOATINGIP_STATUS_NOCHANGE}
@ -915,8 +915,8 @@ class RouterInfo(object):
'PREROUTING', copy_address_scope_for_existing)
def _get_port_devicename_scopemark(self, ports, name_generator):
devicename_scopemark = {l3_constants.IP_VERSION_4: dict(),
l3_constants.IP_VERSION_6: dict()}
devicename_scopemark = {lib_constants.IP_VERSION_4: dict(),
lib_constants.IP_VERSION_6: dict()}
for p in ports:
device_name = name_generator(p['id'])
ip_cidrs = common_utils.fixed_ip_cidrs(p['fixed_ips'])
@ -930,7 +930,7 @@ class RouterInfo(object):
def _get_address_scope_mark(self):
# Prepare address scope iptables rule for internal ports
internal_ports = self.router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
ports_scopemark = self._get_port_devicename_scopemark(
internal_ports, self.get_internal_device_name)
@ -939,8 +939,8 @@ class RouterInfo(object):
if external_port:
external_port_scopemark = self._get_port_devicename_scopemark(
[external_port], self.get_external_device_name)
for ip_version in (l3_constants.IP_VERSION_4,
l3_constants.IP_VERSION_6):
for ip_version in (lib_constants.IP_VERSION_4,
lib_constants.IP_VERSION_6):
ports_scopemark[ip_version].update(
external_port_scopemark[ip_version])
return ports_scopemark
@ -953,13 +953,13 @@ class RouterInfo(object):
external_port['id'])
# Process address scope iptables rules
for ip_version in (l3_constants.IP_VERSION_4,
l3_constants.IP_VERSION_6):
for ip_version in (lib_constants.IP_VERSION_4,
lib_constants.IP_VERSION_6):
scopemarks = ports_scopemark[ip_version]
iptables = iptables_manager.get_tables(ip_version)
iptables['mangle'].empty_chain('scope')
iptables['filter'].empty_chain('scope')
dont_block_external = (ip_version == l3_constants.IP_VERSION_4
dont_block_external = (ip_version == lib_constants.IP_VERSION_4
and self._snat_enabled and external_port)
for device_name, mark in scopemarks.items():
# Add address scope iptables rule
@ -982,7 +982,7 @@ class RouterInfo(object):
return
scopes = external_port.get('address_scopes', {})
return scopes.get(str(l3_constants.IP_VERSION_4))
return scopes.get(str(lib_constants.IP_VERSION_4))
def process_external_port_address_scope_routing(self, iptables_manager):
if not self._snat_enabled:

14
neutron/agent/linux/dhcp.py
View File

@ -353,8 +353,8 @@ class Dnsmasq(DhcpLocalProcess):
# static to preserve previous behavior
addr_mode = getattr(subnet, 'ipv6_address_mode', None)
ra_mode = getattr(subnet, 'ipv6_ra_mode', None)
if (addr_mode in [n_const.DHCPV6_STATEFUL,
n_const.DHCPV6_STATELESS] or
if (addr_mode in [constants.DHCPV6_STATEFUL,
constants.DHCPV6_STATELESS] or
not addr_mode and not ra_mode):
mode = 'static'
@ -510,7 +510,7 @@ class Dnsmasq(DhcpLocalProcess):
fixed_ips,
key=lambda fip: ((fip.subnet_id in v6_nets) and (
v6_nets[fip.subnet_id].ipv6_address_mode == (
n_const.DHCPV6_STATELESS))),
constants.DHCPV6_STATELESS))),
reverse=True)
def _iter_hosts(self):
@ -545,11 +545,11 @@ class Dnsmasq(DhcpLocalProcess):
no_opts = False
if alloc.subnet_id in v6_nets:
addr_mode = v6_nets[alloc.subnet_id].ipv6_address_mode
no_dhcp = addr_mode in (n_const.IPV6_SLAAC,
n_const.DHCPV6_STATELESS)
no_dhcp = addr_mode in (constants.IPV6_SLAAC,
constants.DHCPV6_STATELESS)
# we don't setup anything for SLAAC. It doesn't make sense
# to provide options for a client that won't use DHCP
no_opts = addr_mode == n_const.IPV6_SLAAC
no_opts = addr_mode == constants.IPV6_SLAAC
# If dns_name attribute is supported by ports API, return the
# dns_assignment generated by the Neutron server. Otherwise,
@ -770,7 +770,7 @@ class Dnsmasq(DhcpLocalProcess):
addr_mode = getattr(subnet, 'ipv6_address_mode', None)
if (not subnet.enable_dhcp or
(subnet.ip_version == 6 and
addr_mode == n_const.IPV6_SLAAC)):
addr_mode == constants.IPV6_SLAAC)):
continue
if subnet.dns_nameservers:
options.append(

2
neutron/agent/linux/ip_lib.py
View File

@ -699,7 +699,7 @@ class IpRouteCommand(IpDeviceCommandBase):
with excutils.save_and_reraise_exception() as ctx:
if "Cannot find device" in str(rte):
ctx.reraise = False
raise n_exc.DeviceNotFoundError(device_name=self.name)
raise exceptions.DeviceNotFoundError(device_name=self.name)
def delete_gateway(self, gateway, table=None):
ip_version = get_ip_version(gateway)

6
neutron/agent/linux/ra.py
View File

@ -17,6 +17,7 @@ from itertools import chain as iter_chain
import jinja2
import netaddr
from neutron_lib import constants
from oslo_config import cfg
from oslo_log import log as logging
import six
@ -24,7 +25,7 @@ import six
from neutron._i18n import _
from neutron.agent.linux import external_process
from neutron.agent.linux import utils
from neutron.common import constants
from neutron.common import constants as n_const
from neutron.common import utils as common_utils
@ -53,7 +54,7 @@ CONFIG_TEMPLATE = jinja2.Template("""interface {{ interface_name }}
MinRtrAdvInterval {{ min_rtr_adv_interval }};
MaxRtrAdvInterval {{ max_rtr_adv_interval }};
{% if network_mtu >= constants.IPV6_MIN_MTU %}
{% if network_mtu >= n_const.IPV6_MIN_MTU %}
AdvLinkMTU {{network_mtu}};
{% endif %}
@ -132,6 +133,7 @@ class DaemonMonitor(object):
auto_config_prefixes=auto_config_prefixes,
stateful_config_prefixes=stateful_config_prefixes,
dns_servers=dns_servers[0:MAX_RDNSS_ENTRIES],
n_const=n_const,
constants=constants,
min_rtr_adv_interval=self._agent_conf.min_rtr_adv_interval,
max_rtr_adv_interval=self._agent_conf.max_rtr_adv_interval,

3
neutron/api/api_common.py
View File

@ -28,7 +28,6 @@ from webob import exc
from neutron._i18n import _, _LW
from neutron.common import constants
from neutron.common import exceptions as n_exc
from neutron import wsgi
@ -386,7 +385,7 @@ class NeutronController(object):
def convert_exception_to_http_exc(e, faults, language):
serializer = wsgi.JSONDictSerializer()
if isinstance(e, n_exc.MultipleExceptions):
if isinstance(e, exceptions.MultipleExceptions):
converted_exceptions = [
convert_exception_to_http_exc(inner, faults, language)
for inner in e.inner_exceptions]

5
neutron/api/v2/attributes.py
View File

@ -24,7 +24,6 @@ import webob.exc
from neutron._i18n import _
from neutron.common import _deprecate
from neutron.common import constants as n_const
# Defining a constant to avoid repeating string literal in several modules
@ -280,12 +279,12 @@ RESOURCE_ATTRIBUTE_MAP = {
'is_visible': True},
'ipv6_ra_mode': {'allow_post': True, 'allow_put': False,
'default': constants.ATTR_NOT_SPECIFIED,
'validate': {'type:values': n_const.IPV6_MODES},
'validate': {'type:values': constants.IPV6_MODES},
'is_visible': True},
'ipv6_address_mode': {'allow_post': True, 'allow_put': False,
'default': constants.ATTR_NOT_SPECIFIED,
'validate': {'type:values':
n_const.IPV6_MODES},
constants.IPV6_MODES},
'is_visible': True},
SHARED: {'allow_post': False,
'allow_put': False,

3
neutron/api/v2/router.py
View File

@ -13,6 +13,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from neutron_lib import constants
from oslo_config import cfg
from oslo_service import wsgi as base_wsgi
import routes as routes_mapper
@ -38,7 +39,7 @@ RESOURCES = {'network': 'networks',
SUB_RESOURCES = {}
COLLECTION_ACTIONS = ['index', 'create']
MEMBER_ACTIONS = ['show', 'update', 'delete']
REQUIREMENTS = {'id': attributes.UUID_PATTERN, 'format': 'json'}
REQUIREMENTS = {'id': constants.UUID_PATTERN, 'format': 'json'}
class Index(wsgi.Application):

3
neutron/callbacks/exceptions.py
View File

@ -13,14 +13,13 @@
from neutron_lib import exceptions
from neutron._i18n import _
from neutron.common import exceptions as n_exc
class Invalid(exceptions.NeutronException):
message = _("The value '%(value)s' for %(element)s is not valid.")
class CallbackFailure(n_exc.MultipleExceptions):
class CallbackFailure(exceptions.MultipleExceptions):
def __init__(self, errors):
self.errors = errors

2
neutron/common/constants.py
View File

@ -135,8 +135,6 @@ DVR_FIP_LL_CIDR = '169.254.64.0/18'
L3_HA_NET_CIDR = '169.254.192.0/18'
METADATA_CIDR = '169.254.169.254/32'
DEVICE_OWNER_BAREMETAL_PREFIX = "baremetal:"
# Neutron-lib migration shim. This will wrap any constants that are moved
# to that library in a deprecation warning, until they can be updated to
# import directly from their new location.

25
neutron/common/exceptions.py
View File

@ -21,19 +21,6 @@ from neutron._i18n import _
from neutron.common import _deprecate
class MultipleExceptions(Exception):
"""Container for multiple exceptions encountered.
The API layer of Neutron will automatically unpack, translate,
filter, and combine the inner exceptions in any exception derived
from this class.
"""
def __init__(self, exceptions, *args, **kwargs):
super(MultipleExceptions, self).__init__(*args, **kwargs)
self.inner_exceptions = exceptions
class SubnetPoolNotFound(e.NotFound):
message = _("Subnet pool %(subnetpool_id)s could not be found.")
@ -57,14 +44,6 @@ class NetworkQosBindingNotFound(e.NotFound):
"could not be found.")
class PolicyInitError(e.NeutronException):
message = _("Failed to init policy %(policy)s because %(reason)s.")
class PolicyCheckError(e.NeutronException):
message = _("Failed to check policy %(policy)s because %(reason)s.")
class PolicyRemoveAuthorizationError(e.NotAuthorized):
message = _("Failed to remove provided policy %(policy_id)s "
"because you are not authorized.")
@ -313,10 +292,6 @@ class SubnetPoolQuotaExceeded(e.OverQuota):
message = _("Per-tenant subnet pool prefix quota exceeded.")
class DeviceNotFoundError(e.NeutronException):
message = _("Device '%(device_name)s' does not exist.")
class NetworkSubnetPoolAffinityError(e.BadRequest):
message = _("Subnets hosted on the same network must be allocated from "
"the same subnet pool.")

2
neutron/conf/agent/l3/config.py
View File

@ -14,11 +14,11 @@
# License for the specific language governing permissions and limitations
# under the License.
from neutron_lib import constants
from oslo_config import cfg
from neutron._i18n import _
from neutron.agent.common import config
from neutron.common import constants
OPTS = [

6
neutron/db/api.py
View File

@ -17,6 +17,7 @@ import contextlib
from debtcollector import moves
from debtcollector import removals
from neutron_lib import exceptions
from oslo_config import cfg
from oslo_db import api as oslo_db_api
from oslo_db import exception as db_exc
@ -29,7 +30,6 @@ import sqlalchemy
from sqlalchemy.orm import exc
import traceback
from neutron.common import exceptions
from neutron.common import profiler # noqa
@ -106,12 +106,12 @@ def _is_nested_instance(e, etypes):
@contextlib.contextmanager
def exc_to_retry(exceptions):
def exc_to_retry(etypes):
try:
yield
except Exception as e:
with excutils.save_and_reraise_exception() as ctx:
if _is_nested_instance(e, exceptions):
if _is_nested_instance(e, etypes):
ctx.reraise = False
raise db_exc.RetryRequest(e)

4
neutron/db/db_base_plugin_v2.py
View File

@ -558,8 +558,8 @@ class NeutronDbPluginV2(db_base_plugin_common.DbBasePluginCommon,
"subnets.")
raise exc.BadRequest(resource='subnets', msg=reason)
mode_list = [n_const.IPV6_SLAAC,
n_const.DHCPV6_STATELESS]
mode_list = [constants.IPV6_SLAAC,
constants.DHCPV6_STATELESS]
ra_mode = subnet.get('ipv6_ra_mode')
if ra_mode not in mode_list:

4
neutron/db/external_net_db.py
View File

@ -14,7 +14,7 @@
# under the License.
from neutron_lib.api import validators
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions as n_exc
import sqlalchemy as sa
from sqlalchemy import orm
@ -39,7 +39,7 @@ from neutron import manager
from neutron.plugins.common import constants as service_constants
DEVICE_OWNER_ROUTER_GW = l3_constants.DEVICE_OWNER_ROUTER_GW
DEVICE_OWNER_ROUTER_GW = lib_constants.DEVICE_OWNER_ROUTER_GW
class ExternalNetwork(model_base.BASEV2):

46
neutron/db/l3_db.py
View File

@ -18,7 +18,7 @@ import itertools
from debtcollector import removals
import netaddr
from neutron_lib.api import validators
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions as n_exc
from oslo_log import log as logging
from oslo_utils import excutils
@ -54,10 +54,10 @@ from neutron.plugins.common import utils as p_utils
LOG = logging.getLogger(__name__)
DEVICE_OWNER_HA_REPLICATED_INT = l3_constants.DEVICE_OWNER_HA_REPLICATED_INT
DEVICE_OWNER_ROUTER_INTF = l3_constants.DEVICE_OWNER_ROUTER_INTF
DEVICE_OWNER_ROUTER_GW = l3_constants.DEVICE_OWNER_ROUTER_GW
DEVICE_OWNER_FLOATINGIP = l3_constants.DEVICE_OWNER_FLOATINGIP
DEVICE_OWNER_HA_REPLICATED_INT = lib_constants.DEVICE_OWNER_HA_REPLICATED_INT
DEVICE_OWNER_ROUTER_INTF = lib_constants.DEVICE_OWNER_ROUTER_INTF
DEVICE_OWNER_ROUTER_GW = lib_constants.DEVICE_OWNER_ROUTER_GW
DEVICE_OWNER_FLOATINGIP = lib_constants.DEVICE_OWNER_FLOATINGIP
EXTERNAL_GW_INFO = l3.EXTERNAL_GW_INFO
# Maps API field to DB column
@ -288,12 +288,12 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
def update_router(self, context, id, router):
r = router['router']
gw_info = r.pop(EXTERNAL_GW_INFO, l3_constants.ATTR_NOT_SPECIFIED)
gw_info = r.pop(EXTERNAL_GW_INFO, lib_constants.ATTR_NOT_SPECIFIED)
# check whether router needs and can be rescheduled to the proper
# l3 agent (associated with given external network);
# do check before update in DB as an exception will be raised
# in case no proper l3 agent found
if gw_info != l3_constants.ATTR_NOT_SPECIFIED:
if gw_info != lib_constants.ATTR_NOT_SPECIFIED:
candidates = self._check_router_needs_rescheduling(
context, id, gw_info)
# Update the gateway outside of the DB update since it involves L2
@ -341,7 +341,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
constants.L3_ROUTER_NAT)
if (not utils.is_extension_supported(
l3_plugin,
l3_constants.L3_AGENT_SCHEDULER_EXT_ALIAS) or
lib_constants.L3_AGENT_SCHEDULER_EXT_ALIAS) or
l3_plugin.router_scheduler is None):
# that might mean that we are dealing with non-agent-based
# implementation of l3 services
@ -378,7 +378,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
# Port has no 'tenant-id', as it is hidden from user
port_data = {'tenant_id': '', # intentionally not set
'network_id': network_id,
'fixed_ips': ext_ips or l3_constants.ATTR_NOT_SPECIFIED,
'fixed_ips': ext_ips or lib_constants.ATTR_NOT_SPECIFIED,
'device_id': router['id'],
'device_owner': DEVICE_OWNER_ROUTER_GW,
'admin_state_up': True,
@ -1018,11 +1018,11 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
RouterPort.router_id, models_v2.IPAllocation.ip_address).join(
models_v2.Port, models_v2.IPAllocation).filter(
models_v2.Port.network_id == internal_port['network_id'],
RouterPort.port_type.in_(l3_constants.ROUTER_INTERFACE_OWNERS),
RouterPort.port_type.in_(lib_constants.ROUTER_INTERFACE_OWNERS),
models_v2.IPAllocation.subnet_id == internal_subnet['id']
).join(gw_port, gw_port.device_id == RouterPort.router_id).filter(
gw_port.network_id == external_network_id,
gw_port.device_owner == l3_constants.DEVICE_OWNER_ROUTER_GW
gw_port.device_owner == lib_constants.DEVICE_OWNER_ROUTER_GW
).distinct()
first_router_id = None
@ -1171,7 +1171,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
gw_port = router.gw_port
for fixed_ip in gw_port.fixed_ips:
addr = netaddr.IPAddress(fixed_ip.ip_address)
if addr.version == l3_constants.IP_VERSION_4:
if addr.version == lib_constants.IP_VERSION_4:
next_hop = fixed_ip.ip_address
break
args = {'fixed_ip_address': internal_ip_address,
@ -1192,7 +1192,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
return any(s.ip_version == 4 for s in net.subnets)
def _create_floatingip(self, context, floatingip,
initial_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
initial_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
fip = floatingip['floatingip']
fip_id = uuidutils.generate_uuid()
@ -1215,7 +1215,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
'admin_state_up': True,
'device_id': fip_id,
'device_owner': DEVICE_OWNER_FLOATINGIP,
'status': l3_constants.PORT_STATUS_NOTAPPLICABLE,
'status': lib_constants.PORT_STATUS_NOTAPPLICABLE,
'name': ''}
if fip.get('floating_ip_address'):
port['fixed_ips'] = [
@ -1268,7 +1268,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
return floatingip_dict
def create_floatingip(self, context, floatingip,
initial_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
initial_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
return self._create_floatingip(context, floatingip, initial_status)
def _update_floatingip(self, context, id, floatingip):
@ -1606,8 +1606,8 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
port['subnets'] = []
port['extra_subnets'] = []
port['address_scopes'] = {l3_constants.IP_VERSION_4: None,
l3_constants.IP_VERSION_6: None}
port['address_scopes'] = {lib_constants.IP_VERSION_4: None,
lib_constants.IP_VERSION_6: None}
scopes = {}
for subnet in subnets_by_network[port['network_id']]:
@ -1642,18 +1642,18 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
for floating_ip in floating_ips:
router = routers_dict.get(floating_ip['router_id'])
if router:
router_floatingips = router.get(l3_constants.FLOATINGIP_KEY,
router_floatingips = router.get(lib_constants.FLOATINGIP_KEY,
[])
router_floatingips.append(floating_ip)
router[l3_constants.FLOATINGIP_KEY] = router_floatingips
router[lib_constants.FLOATINGIP_KEY] = router_floatingips
def _process_interfaces(self, routers_dict, interfaces):
for interface in interfaces:
router = routers_dict.get(interface['device_id'])
if router:
router_interfaces = router.get(l3_constants.INTERFACE_KEY, [])
router_interfaces = router.get(lib_constants.INTERFACE_KEY, [])
router_interfaces.append(interface)
router[l3_constants.INTERFACE_KEY] = router_interfaces
router[lib_constants.INTERFACE_KEY] = router_interfaces
def _get_router_info_list(self, context, router_ids=None, active=None,
device_owners=None):
@ -1780,7 +1780,7 @@ class L3_NAT_db_mixin(L3_NAT_dbonly_mixin, L3RpcNotifierMixin):
return router_interface_info
def create_floatingip(self, context, floatingip,
initial_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
initial_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
floatingip_dict = super(L3_NAT_db_mixin, self).create_floatingip(
context, floatingip, initial_status)
router_id = floatingip_dict['router_id']
@ -1852,7 +1852,7 @@ def _notify_subnet_gateway_ip_update(resource, event, trigger, **kwargs):
subnet_id = kwargs['subnet_id']
query = context.session.query(models_v2.Port).filter_by(
network_id=network_id,
device_owner=l3_constants.DEVICE_OWNER_ROUTER_GW)
device_owner=lib_constants.DEVICE_OWNER_ROUTER_GW)
query = query.join(models_v2.Port.fixed_ips).filter(
models_v2.IPAllocation.subnet_id == subnet_id)
router_ids = set(port['device_id'] for port in query)

5
neutron/db/migration/alembic_migrations/versions/newton/contract/a8b517cff8ab_add_routerport_bindings_for_ha.py
View File

@ -23,6 +23,7 @@ revision = 'a8b517cff8ab'
down_revision = '7d9d8eeec6ad'
from alembic import op
from neutron_lib import constants as lib_const
import sqlalchemy as sa
from neutron.common import constants
@ -57,11 +58,11 @@ def upgrade():
# as a result of Ifd3e007aaf2a2ed8123275aa3a9f540838e3c003 being
# back-ported
for router_port in session.query(router_ports).filter(
router_ports.c.port_type == constants.DEVICE_OWNER_ROUTER_HA_INTF):
router_ports.c.port_type == lib_const.DEVICE_OWNER_ROUTER_HA_INTF):
router_port_tuples.discard((router_port.router_id,
router_port.port_id))
new_records = [dict(router_id=router_id, port_id=port_id,
port_type=constants.DEVICE_OWNER_ROUTER_HA_INTF)
port_type=lib_const.DEVICE_OWNER_ROUTER_HA_INTF)
for router_id, port_id in router_port_tuples]
op.bulk_insert(router_ports, new_records)
session.commit()

3
neutron/db/migration/alembic_migrations/versions/newton/expand/030a959ceafa_uniq_routerports0port_id.py
View File

@ -26,12 +26,11 @@ revision = '030a959ceafa'
down_revision = '3d0e74aa7d37'
from alembic import op
from neutron_lib import exceptions
import sqlalchemy as sa
from neutron._i18n import _
from neutron.common import exceptions
routerports = sa.Table(
'routerports', sa.MetaData(),
sa.Column('router_id', sa.String(36)),

10
neutron/db/models_v2.py
View File

@ -213,11 +213,13 @@ class Subnet(model_base.HasStandardAttributes, model_base.BASEV2,
ipv6_ra_mode = sa.Column(sa.Enum(constants.IPV6_SLAAC,
constants.DHCPV6_STATEFUL,
constants.DHCPV6_STATELESS,
name='ipv6_ra_modes'), nullable=True)
name='ipv6_ra_modes'),
nullable=True)
ipv6_address_mode = sa.Column(sa.Enum(constants.IPV6_SLAAC,
constants.DHCPV6_STATEFUL,
constants.DHCPV6_STATELESS,
name='ipv6_address_modes'), nullable=True)
constants.DHCPV6_STATEFUL,
constants.DHCPV6_STATELESS,
name='ipv6_address_modes'),
nullable=True)
# subnets don't have their own rbac_entries, they just inherit from
# the network rbac entries
rbac_entries = orm.relationship(

3
neutron/notifiers/nova.py
View File

@ -27,7 +27,6 @@ from neutron._i18n import _LE, _LI, _LW
from neutron.callbacks import events
from neutron.callbacks import registry
from neutron.callbacks import resources
from neutron.common import constants as n_const
from neutron import context
from neutron import manager
from neutron.notifiers import batch_notifier
@ -87,7 +86,7 @@ class Notifier(object):
if (port['device_id'] and uuidutils.is_uuid_like(port['device_id'])
and port['device_owner'].startswith((
constants.DEVICE_OWNER_COMPUTE_PREFIX,
n_const.DEVICE_OWNER_BAREMETAL_PREFIX))):
constants.DEVICE_OWNER_BAREMETAL_PREFIX))):
return True
except (KeyError, AttributeError):
pass

12
neutron/objects/common_types.py
View File

@ -14,13 +14,13 @@
import itertools
import netaddr
from neutron_lib import constants as n_const
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions
from oslo_versionedobjects import fields as obj_fields
import six
from neutron._i18n import _
from neutron.common import constants
from neutron.common import exceptions
class NeutronRangeConstrainedIntegerInvalidLimit(exceptions.NeutronException):
@ -29,7 +29,7 @@ class NeutronRangeConstrainedIntegerInvalidLimit(exceptions.NeutronException):
class IPV6ModeEnumField(obj_fields.AutoTypedField):
AUTO_TYPE = obj_fields.Enum(valid_values=constants.IPV6_MODES)
AUTO_TYPE = obj_fields.Enum(valid_values=lib_constants.IPV6_MODES)
class RangeConstrainedInteger(obj_fields.Integer):
@ -56,7 +56,7 @@ class IPNetworkPrefixLen(RangeConstrainedInteger):
"""IP network (CIDR) prefix length custom Enum"""
def __init__(self, **kwargs):
super(IPNetworkPrefixLen, self).__init__(
start=0, end=n_const.IPv6_BITS,
start=0, end=lib_constants.IPv6_BITS,
**kwargs)
@ -139,8 +139,8 @@ class IpProtocolEnum(obj_fields.Enum):
super(IpProtocolEnum, self).__init__(
valid_values=list(
itertools.chain(
n_const.IP_PROTOCOL_MAP.keys(),
[str(v) for v in n_const.IP_PROTOCOL_MAP.values()]
lib_constants.IP_PROTOCOL_MAP.keys(),
[str(v) for v in lib_constants.IP_PROTOCOL_MAP.values()]
)
),
**kwargs)

2
neutron/pecan_wsgi/hooks/policy_enforcement.py
View File

@ -176,7 +176,7 @@ class PolicyHook(hooks.PecanHook):
# This exception must be explicitly caught as the exception
# translation hook won't be called if an error occurs in the
# 'after' handler.
raise webob.exc.HTTPForbidden(e.message)
raise webob.exc.HTTPForbidden(str(e))
if is_single:
resp = resp[0]

3
neutron/plugins/ml2/drivers/l2pop/rpc_manager/l2population_rpc.py
View File

@ -239,7 +239,8 @@ class L2populationRpcCallBackTunnelMixin(L2populationRpcCallBackMixin):
if local_vlan_map is not None:
vlanmanager.deprecate_local_vlan_map_in_object(
"%s.get_agent_ports()" % self.__class__.__name__)
"%s.get_agent_ports()" % self.__class__.__name__,
stacklevel_extra=1)
return get_lvm_from_mapping
return get_lvm_from_manager

5
neutron/plugins/ml2/drivers/openvswitch/agent/vlanmanager.py
View File

@ -19,10 +19,11 @@ from neutron_lib import exceptions
from neutron._i18n import _
def deprecate_local_vlan_map_in_object(object_name):
def deprecate_local_vlan_map_in_object(object_name, stacklevel_extra=0):
debtcollector.deprecate(
"local_vlan_map argument for %s was deprecated." % object_name,
version="Newton", removal_version="Ocata")
version="Newton", removal_version="Ocata",
stacklevel=4 + stacklevel_extra)
class VifIdNotFound(exceptions.NeutronException):

5
neutron/policy.py
View File

@ -17,7 +17,7 @@ import collections
import re
from neutron_lib import constants
from neutron_lib import exceptions as lib_exc
from neutron_lib import exceptions
from oslo_config import cfg
from oslo_db import exception as db_exc
from oslo_log import log as logging
@ -29,7 +29,6 @@ import six
from neutron._i18n import _, _LE, _LW
from neutron.api.v2 import attributes
from neutron.common import constants as const
from neutron.common import exceptions
LOG = logging.getLogger(__name__)
@ -265,7 +264,7 @@ class OwnerCheck(policy.Check):
target[parent_foreign_key],
fields=[parent_field])
target[self.target_field] = data[parent_field]
except lib_exc.NotFound as e:
except exceptions.NotFound as e:
# NOTE(kevinbenton): a NotFound exception can occur if a
# list operation is happening at the same time as one of
# the parents and its children being deleted. So we issue

10
neutron/services/l3_router/service_providers/driver_controller.py
View File

@ -13,6 +13,7 @@
# under the License.
from neutron_lib import constants as lib_const
from neutron_lib import exceptions as lib_exc
from oslo_config import cfg
from oslo_log import log as logging
@ -20,7 +21,6 @@ from neutron._i18n import _
from neutron.callbacks import events
from neutron.callbacks import registry
from neutron.callbacks import resources
from neutron.common import exceptions as n_exc
from neutron.db import servicetype_db as st_db
from neutron import manager
from neutron.plugins.common import constants
@ -110,7 +110,7 @@ class DriverController(object):
# attributes via the API.
try:
_ensure_driver_supports_request(drv, router)
except n_exc.Invalid:
except lib_exc.Invalid:
# the current driver does not support this request, we need to
# migrate to a new provider. populate the distributed and ha
# flags from the previous state if not in the update so we can
@ -120,7 +120,7 @@ class DriverController(object):
# the flavor will make things inconsistent. We can probably
# update the flavor automatically in the future.
if old_router['flavor_id']:
raise n_exc.Invalid(_(
raise lib_exc.Invalid(_(
"Changing the 'ha' and 'distributed' attributes on a "
"router associated with a flavor is not supported."))
if 'distributed' not in router:
@ -202,7 +202,7 @@ class _LegacyPlusProviderConfiguration(
self.add_provider({'service_type': constants.L3_ROUTER_NAT,
'name': name, 'driver': path,
'default': False})
except n_exc.Invalid:
except lib_exc.Invalid:
LOG.debug("Could not add L3 provider '%s', it may have "
"already been explicitly defined.", name)
@ -244,6 +244,6 @@ def _ensure_driver_supports_request(drv, router_body):
if flag not in [True, False]:
continue # not specified in body
if not getattr(drv, attr).is_compatible(flag):
raise n_exc.Invalid(
raise lib_exc.Invalid(
_("Provider %(name)s does not support %(key)s=%(flag)s")
% dict(name=drv.name, key=key, flag=flag))

5
neutron/services/provider_configuration.py
View File

@ -13,7 +13,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import debtcollector
import importlib
import itertools
import os
@ -32,9 +31,7 @@ LOG = logging.getLogger(__name__)
SERVICE_PROVIDERS = 'neutron.service_providers'
debtcollector.deprecate(
'Moved serviceprovider_opts to %s' % prov_config.__name__,
version="newton", removal_version="ocata")
# TODO(HenryG): use MovedGlobals to deprecate this.
serviceprovider_opts = prov_config.serviceprovider_opts
prov_config.register_service_provider_opts()

3
neutron/tests/common/helpers.py
View File

@ -22,7 +22,6 @@ import six
import testtools
import neutron
from neutron.common import constants as n_const
from neutron.common import topics
from neutron import context
from neutron.db import agents_db
@ -79,7 +78,7 @@ def _register_agent(agent, plugin=None):
admin_context, agent['agent_type'], agent['host'])
def register_l3_agent(host=HOST, agent_mode=n_const.L3_AGENT_MODE_LEGACY,
def register_l3_agent(host=HOST, agent_mode=constants.L3_AGENT_MODE_LEGACY,
internal_only=True, ext_net_id='', ext_bridge='',
az=DEFAULT_AZ):
agent = _get_l3_agent_dict(host, agent_mode, internal_only, ext_net_id,

22
neutron/tests/common/l3_test_common.py
View File

@ -15,7 +15,7 @@
import copy
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_utils import uuidutils
from six import moves
@ -33,7 +33,7 @@ def get_ha_interface(ip='169.254.192.1', mac='12:34:56:78:2b:5d'):
subnet_id = _uuid()
return {'admin_state_up': True,
'device_id': _uuid(),
'device_owner': l3_constants.DEVICE_OWNER_ROUTER_HA_INTF,
'device_owner': lib_constants.DEVICE_OWNER_ROUTER_HA_INTF,
'fixed_ips': [{'ip_address': ip,
'prefixlen': 18,
'subnet_id': subnet_id}],
@ -103,12 +103,12 @@ def prepare_router_data(ip_version=4, enable_snat=None, num_internal_ports=1,
router = {
'id': router_id,
'distributed': False,
l3_constants.INTERFACE_KEY: [],
lib_constants.INTERFACE_KEY: [],
'routes': routes,
'gw_port': ex_gw_port}
if enable_floating_ip:
router[l3_constants.FLOATINGIP_KEY] = [{
router[lib_constants.FLOATINGIP_KEY] = [{
'id': _uuid(),
'port_id': _uuid(),
'status': 'DOWN',
@ -120,7 +120,7 @@ def prepare_router_data(ip_version=4, enable_snat=None, num_internal_ports=1,
if enable_ha:
router['ha'] = True
router['ha_vr_id'] = 1
router[l3_constants.HA_INTERFACE_KEY] = (get_ha_interface())
router[lib_constants.HA_INTERFACE_KEY] = (get_ha_interface())
if enable_snat is not None:
router['enable_snat'] = enable_snat
@ -133,7 +133,7 @@ def get_subnet_id(port):
def router_append_interface(router, count=1, ip_version=4, ra_mode=None,
addr_mode=None, dual_stack=False):
interfaces = router[l3_constants.INTERFACE_KEY]
interfaces = router[lib_constants.INTERFACE_KEY]
current = sum(
[netaddr.IPNetwork(subnet['cidr']).version == ip_version
for p in interfaces for subnet in p['subnets']])
@ -203,7 +203,7 @@ def router_append_subnet(router, count=1, ip_version=4,
else:
raise ValueError("Invalid ip_version: %s" % ip_version)
interfaces = copy.deepcopy(router.get(l3_constants.INTERFACE_KEY, []))
interfaces = copy.deepcopy(router.get(lib_constants.INTERFACE_KEY, []))
if interface_id:
try:
interface = next(i for i in interfaces
@ -248,11 +248,11 @@ def router_append_subnet(router, count=1, ip_version=4,
'fixed_ips': fixed_ips,
'subnets': subnets})
router[l3_constants.INTERFACE_KEY] = interfaces
router[lib_constants.INTERFACE_KEY] = interfaces
def router_append_pd_enabled_subnet(router, count=1):
interfaces = router[l3_constants.INTERFACE_KEY]
interfaces = router[lib_constants.INTERFACE_KEY]
current = sum(netaddr.IPNetwork(subnet['cidr']).version == 6
for p in interfaces for subnet in p['subnets'])
@ -271,8 +271,8 @@ def router_append_pd_enabled_subnet(router, count=1):
'subnets': [{'id': subnet_id,
'cidr': n_const.PROVISIONAL_IPV6_PD_PREFIX,
'gateway_ip': '::1',
'ipv6_ra_mode': n_const.IPV6_SLAAC,
'subnetpool_id': l3_constants.IPV6_PD_POOL_ID}]}
'ipv6_ra_mode': lib_constants.IPV6_SLAAC,
'subnetpool_id': lib_constants.IPV6_PD_POOL_ID}]}
interfaces.append(intf)
pd_intfs.append(intf)
mac_address.value += 1

27
neutron/tests/functional/agent/l3/framework.py
View File

@ -17,7 +17,7 @@ import functools
import mock
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import uuidutils
@ -29,7 +29,6 @@ from neutron.agent.l3 import agent as neutron_l3_agent
from neutron.agent import l3_agent as l3_agent_main
from neutron.agent.linux import external_process
from neutron.agent.linux import ip_lib
from neutron.common import constants as n_const
from neutron.common import utils as common_utils
from neutron.conf import common as common_config
from neutron.tests.common import l3_test_common
@ -123,13 +122,13 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
router_info = self.generate_router_info(enable_ha=ha)
router = self.manage_router(self.agent, router_info)
port = net_helpers.get_free_namespace_port(l3_constants.PROTO_NAME_TCP,
router.ns_name)
port = net_helpers.get_free_namespace_port(
constants.PROTO_NAME_TCP, router.ns_name)
client_address = '19.4.4.3'
server_address = '35.4.0.4'
def clean_fips(router):
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[constants.FLOATINGIP_KEY] = []
clean_fips(router)
self._add_fip(router, client_address, fixed_address=server_address)
@ -170,8 +169,8 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
# Assert that every defined FIP is updated via RPC
expected_fips = set([
(fip['id'], l3_constants.FLOATINGIP_STATUS_ACTIVE) for fip in
router.router[l3_constants.FLOATINGIP_KEY]])
(fip['id'], constants.FLOATINGIP_STATUS_ACTIVE) for fip in
router.router[constants.FLOATINGIP_KEY]])
call = [args[0] for args in rpc.call_args_list][0]
actual_fips = set(
[(fip_id, status) for fip_id, status in call[2].items()])
@ -188,7 +187,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
def ha_router_dev_name_getter(not_used):
return router.get_ha_device_name()
self.assertTrue(self.device_exists_with_ips_and_mac(
router.router[l3_constants.HA_INTERFACE_KEY],
router.router[constants.HA_INTERFACE_KEY],
ha_router_dev_name_getter, router.ns_name))
def _assert_gateway(self, router, v6_ext_gw_with_sub=True):
@ -227,7 +226,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
router = self.manage_router(self.agent, router_info)
# Add multiple-IPv6-prefix internal router port
slaac = n_const.IPV6_SLAAC
slaac = constants.IPV6_SLAAC
slaac_mode = {'ra_mode': slaac, 'address_mode': slaac}
subnet_modes = [slaac_mode] * 2
self._add_internal_interface_by_subnet(router.router,
@ -247,7 +246,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
# not when it ends. Thus, we have to wait until keepalived finishes
# configuring everything. We verify this by waiting until the last
# device has an IP address.
device = router.router[l3_constants.INTERFACE_KEY][-1]
device = router.router[constants.INTERFACE_KEY][-1]
device_exists = functools.partial(
self.device_exists_with_ips_and_mac,
device,
@ -308,7 +307,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
'fixed_ip_address': fixed_address,
'host': host,
'fixed_ip_address_scope': fixed_ip_address_scope}
router.router[l3_constants.FLOATINGIP_KEY].append(fip)
router.router[constants.FLOATINGIP_KEY].append(fip)
def _add_internal_interface_by_subnet(self, router, count=1,
ip_version=4,
@ -352,7 +351,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
external_device_name = router.get_external_device_name(
external_port['id'])
external_device_cidr = self._port_first_ip_cidr(external_port)
internal_port = router.router[l3_constants.INTERFACE_KEY][0]
internal_port = router.router[constants.INTERFACE_KEY][0]
int_port_ipv6 = ip_lib.get_ipv6_lladdr(internal_port['mac_address'])
internal_device_name = router.get_internal_device_name(
internal_port['id'])
@ -442,7 +441,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
metadata_port_filter))
def _assert_internal_devices(self, router):
internal_devices = router.router[l3_constants.INTERFACE_KEY]
internal_devices = router.router[constants.INTERFACE_KEY]
self.assertTrue(len(internal_devices))
for device in internal_devices:
self.assertTrue(self.device_exists_with_ips_and_mac(
@ -481,7 +480,7 @@ class L3AgentTestFramework(base.BaseSudoTestCase):
assert_ovs_bridge_empty(self.agent.conf.external_network_bridge)
def floating_ips_configured(self, router):
floating_ips = router.router[l3_constants.FLOATINGIP_KEY]
floating_ips = router.router[constants.FLOATINGIP_KEY]
external_port = router.get_ex_gw_port()
return len(floating_ips) and all(
ip_lib.device_exists_with_ips_and_mac(

38
neutron/tests/functional/agent/l3/test_dvr_router.py
View File

@ -18,7 +18,7 @@ import functools
import mock
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
import testtools
from neutron.agent.l3 import agent as neutron_l3_agent
@ -36,7 +36,7 @@ from neutron.tests.common import net_helpers
from neutron.tests.functional.agent.l3 import framework
DEVICE_OWNER_COMPUTE = l3_constants.DEVICE_OWNER_COMPUTE_PREFIX + 'fake'
DEVICE_OWNER_COMPUTE = lib_constants.DEVICE_OWNER_COMPUTE_PREFIX + 'fake'
class TestDvrRouter(framework.L3AgentTestFramework):
@ -112,7 +112,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
'gateway_ip': float_subnet['gateway_ip'],
'id': fixed_ip['subnet_id']}],
'network_id': external_gw_port['network_id'],
'device_owner': l3_constants.DEVICE_OWNER_AGENT_GW,
'device_owner': lib_constants.DEVICE_OWNER_AGENT_GW,
'mac_address': 'fa:16:3e:80:8f:89',
portbindings.HOST_ID: self.agent.conf.host,
'fixed_ips': [{'subnet_id': fixed_ip['subnet_id'],
@ -239,7 +239,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
# not when it ends. Thus, we have to wait until keepalived finishes
# configuring everything. We verify this by waiting until the last
# device has an IP address.
device = router.router[l3_constants.INTERFACE_KEY][-1]
device = router.router[lib_constants.INTERFACE_KEY][-1]
device_exists = functools.partial(
self.device_exists_with_ips_and_mac,
device,
@ -298,7 +298,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
num_internal_ports=2,
enable_gw=enable_gw,
**kwargs)
internal_ports = router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = router.get(lib_constants.INTERFACE_KEY, [])
router['distributed'] = True
router['gw_port_host'] = agent.conf.host
@ -339,7 +339,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
'gateway_ip': float_subnet['gateway_ip'],
'id': fixed_ip['subnet_id']}],
'network_id': external_gw_port['network_id'],
'device_owner': l3_constants.DEVICE_OWNER_AGENT_GW,
'device_owner': lib_constants.DEVICE_OWNER_AGENT_GW,
'mac_address': 'fa:16:3e:80:8d:89',
portbindings.HOST_ID: self.agent.conf.host,
'fixed_ips': [{'subnet_id': fixed_ip['subnet_id'],
@ -370,7 +370,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
'gateway_ip': snat_subnet['gateway_ip'],
'id': fixed_ip['subnet_id']}],
'network_id': port['network_id'],
'device_owner': l3_constants.DEVICE_OWNER_ROUTER_SNAT,
'device_owner': lib_constants.DEVICE_OWNER_ROUTER_SNAT,
'mac_address': 'fa:16:3e:80:8d:89',
'fixed_ips': [{'subnet_id': fixed_ip['subnet_id'],
'ip_address': snat_ip,
@ -457,7 +457,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
# in the fip namespace:
# Check that the fg-<port-id> (floatingip_agent_gateway)
# is created with the ip address of the external gateway port
floating_ips = router.router[l3_constants.FLOATINGIP_KEY]
floating_ips = router.router[lib_constants.FLOATINGIP_KEY]
self.assertTrue(floating_ips)
# We need to fetch the floatingip agent gateway port info
# from the router_info
@ -504,7 +504,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
self.assertTrue(self._namespace_exists(fip_ns))
restarted_agent = neutron_l3_agent.L3NATAgentWithStateReport(
self.agent.host, self.agent.conf)
router1.router[l3_constants.FLOATINGIP_KEY] = []
router1.router[lib_constants.FLOATINGIP_KEY] = []
self.manage_router(restarted_agent, router1.router)
self._assert_dvr_snat_gateway(router1)
self.assertTrue(self._namespace_exists(fip_ns))
@ -513,7 +513,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
self.agent.conf.agent_mode = 'dvr'
router_info = self.generate_dvr_router_info()
router = self.manage_router(self.agent, router_info)
floating_ips = router.router[l3_constants.FLOATINGIP_KEY]
floating_ips = router.router[lib_constants.FLOATINGIP_KEY]
router_ns = router.ns_name
fip_rule_prio_1 = self._get_fixed_ip_rule_priority(
router_ns, floating_ips[0]['fixed_ip_address'])
@ -530,7 +530,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
self.agent.conf.agent_mode = 'dvr'
router_info = self.generate_dvr_router_info()
router = self.manage_router(self.agent, router_info)
floating_ips = router.router[l3_constants.FLOATINGIP_KEY]
floating_ips = router.router[lib_constants.FLOATINGIP_KEY]
router_ns = router.ns_name
fixed_ip = floating_ips[0]['fixed_ip_address']
self.assertTrue(self._fixed_ip_rule_exists(router_ns, fixed_ip))
@ -730,7 +730,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
self.assertEqual(router1.snat_ports, snat_internal_port)
# Now let us not pass INTERFACE_KEY, to emulate
# the interface has been removed.
router1.router[l3_constants.INTERFACE_KEY] = []
router1.router[lib_constants.INTERFACE_KEY] = []
# Now let us not pass the SNAT_ROUTER_INTF_KEY, to emulate
# that the server did not send it, since the interface has been
# removed.
@ -923,20 +923,20 @@ class TestDvrRouter(framework.L3AgentTestFramework):
internal_address_scope2, gw_address_scope=None):
router_info = self.generate_dvr_router_info(enable_snat=True)
address_scope1 = {
str(l3_constants.IP_VERSION_4): internal_address_scope1}
str(lib_constants.IP_VERSION_4): internal_address_scope1}
address_scope2 = {
str(l3_constants.IP_VERSION_4): internal_address_scope2}
str(lib_constants.IP_VERSION_4): internal_address_scope2}
if gw_address_scope:
router_info['gw_port']['address_scopes'] = {
str(l3_constants.IP_VERSION_4): gw_address_scope}
router_info[l3_constants.INTERFACE_KEY][0]['address_scopes'] = (
str(lib_constants.IP_VERSION_4): gw_address_scope}
router_info[lib_constants.INTERFACE_KEY][0]['address_scopes'] = (
address_scope1)
router_info[l3_constants.INTERFACE_KEY][1]['address_scopes'] = (
router_info[lib_constants.INTERFACE_KEY][1]['address_scopes'] = (
address_scope2)
# Renew the address scope
router_info[n_const.SNAT_ROUTER_INTF_KEY] = []
self._add_snat_port_info_to_router(
router_info, router_info[l3_constants.INTERFACE_KEY])
router_info, router_info[lib_constants.INTERFACE_KEY])
router = self.manage_router(self.agent, router_info)
router_ip_cidr1 = self._port_first_ip_cidr(router.internal_ports[0])
@ -983,7 +983,7 @@ class TestDvrRouter(framework.L3AgentTestFramework):
(machine_same_scope, machine_diff_scope,
router) = self._setup_address_scope('scope1', 'scope2', 'scope1')
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[lib_constants.FLOATINGIP_KEY] = []
fip_same_scope = '19.4.4.10'
self._add_fip(router, fip_same_scope,
fixed_address=machine_same_scope.ip,

19
neutron/tests/functional/agent/l3/test_ha_router.py
View File

@ -16,14 +16,13 @@
import copy
import mock
from neutron_lib import constants as l3_constants
from neutron_lib import constants
import six
import testtools
from neutron.agent.l3 import agent as neutron_l3_agent
from neutron.agent.l3 import namespaces
from neutron.agent.linux import ip_lib
from neutron.common import constants
from neutron.common import ipv6_utils
from neutron.common import utils as common_utils
from neutron.tests.common import l3_test_common
@ -181,7 +180,7 @@ class L3HATestCase(framework.L3AgentTestFramework):
common_utils.wait_until_true(lambda: router1.radvd.enabled)
def _check_lla_status(router, expected):
internal_devices = router.router[l3_constants.INTERFACE_KEY]
internal_devices = router.router[constants.INTERFACE_KEY]
for device in internal_devices:
lladdr = ip_lib.get_ipv6_lladdr(device['mac_address'])
exists = ip_lib.device_exists_with_ips_and_mac(
@ -210,7 +209,7 @@ class L3HATestCase(framework.L3AgentTestFramework):
for ip_addr in ip_cidrs:
self.assertIn(ip_addr, config)
interface_id = router.router[l3_constants.INTERFACE_KEY][0]['id']
interface_id = router.router[constants.INTERFACE_KEY][0]['id']
slaac = constants.IPV6_SLAAC
slaac_mode = {'ra_mode': slaac, 'address_mode': slaac}
@ -223,7 +222,7 @@ class L3HATestCase(framework.L3AgentTestFramework):
# Verify that router internal interface is present and is configured
# with IP address from both the subnets.
internal_iface = router.router[l3_constants.INTERFACE_KEY][0]
internal_iface = router.router[constants.INTERFACE_KEY][0]
self.assertEqual(2, len(internal_iface['fixed_ips']))
self._assert_internal_devices(router)
@ -232,16 +231,16 @@ class L3HATestCase(framework.L3AgentTestFramework):
# Remove one subnet from the router internal iface
interfaces = copy.deepcopy(router.router.get(
l3_constants.INTERFACE_KEY, []))
constants.INTERFACE_KEY, []))
fixed_ips, subnets = [], []
fixed_ips.append(interfaces[0]['fixed_ips'][0])
subnets.append(interfaces[0]['subnets'][0])
interfaces[0].update({'fixed_ips': fixed_ips, 'subnets': subnets})
router.router[l3_constants.INTERFACE_KEY] = interfaces
router.router[constants.INTERFACE_KEY] = interfaces
router.process(self.agent)
# Verify that router internal interface has a single ipaddress
internal_iface = router.router[l3_constants.INTERFACE_KEY][0]
internal_iface = router.router[constants.INTERFACE_KEY][0]
self.assertEqual(1, len(internal_iface['fixed_ips']))
self._assert_internal_devices(router)
@ -268,7 +267,7 @@ class L3HATestCase(framework.L3AgentTestFramework):
common_utils.wait_until_true(lambda: router.ha_state == 'master')
self._add_fip(router, '172.168.1.20', fixed_address='10.0.0.3')
router.process(self.agent)
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[constants.FLOATINGIP_KEY] = []
# The purpose of the test is to simply make sure no exception is raised
# Because router.process will consume the FloatingIpSetupException,
# call the configure_fip_addresses directly here
@ -302,7 +301,7 @@ class L3HATestFailover(framework.L3AgentTestFramework):
router1 = self.manage_router(self.agent, router_info)
router_info_2 = copy.deepcopy(router_info)
router_info_2[l3_constants.HA_INTERFACE_KEY] = (
router_info_2[constants.HA_INTERFACE_KEY] = (
l3_test_common.get_ha_interface(ip='169.254.192.2',
mac='22:22:22:22:22:22'))

22
neutron/tests/functional/agent/l3/test_legacy_router.py
View File

@ -16,7 +16,7 @@
import copy
import mock
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron.agent.l3 import namespace_manager
from neutron.agent.l3 import namespaces
@ -137,7 +137,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
gw_inf_name = router.get_external_device_name(gw_port['id'])
gw_device = ip_lib.IPDevice(gw_inf_name, namespace=router.ns_name)
router_ports = [gw_device]
for i_port in router_info.get(l3_constants.INTERFACE_KEY, []):
for i_port in router_info.get(lib_constants.INTERFACE_KEY, []):
interface_name = router.get_internal_device_name(i_port['id'])
router_ports.append(
ip_lib.IPDevice(interface_name, namespace=router.ns_name))
@ -265,7 +265,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
router_ip)).machines
dst_fip = '19.4.4.10'
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[lib_constants.FLOATINGIP_KEY] = []
self._add_fip(router, dst_fip, fixed_address=dst_machine.ip)
router.process(self.agent)
@ -280,7 +280,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
src_machine, dst_machine, dst_fip = (
self._setup_fip_with_fixed_ip_from_same_subnet(enable_snat=True))
protocol_port = net_helpers.get_free_namespace_port(
l3_constants.PROTO_NAME_TCP, dst_machine.namespace)
lib_constants.PROTO_NAME_TCP, dst_machine.namespace)
# client sends to fip
netcat = net_helpers.NetcatTester(
src_machine.namespace, dst_machine.namespace,
@ -304,15 +304,15 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
router_info = self.generate_router_info(enable_ha=False,
num_internal_ports=2)
address_scope1 = {
str(l3_constants.IP_VERSION_4): internal_address_scope1}
str(lib_constants.IP_VERSION_4): internal_address_scope1}
address_scope2 = {
str(l3_constants.IP_VERSION_4): internal_address_scope2}
str(lib_constants.IP_VERSION_4): internal_address_scope2}
if gw_address_scope:
router_info['gw_port']['address_scopes'] = {
str(l3_constants.IP_VERSION_4): gw_address_scope}
router_info[l3_constants.INTERFACE_KEY][0]['address_scopes'] = (
str(lib_constants.IP_VERSION_4): gw_address_scope}
router_info[lib_constants.INTERFACE_KEY][0]['address_scopes'] = (
address_scope1)
router_info[l3_constants.INTERFACE_KEY][1]['address_scopes'] = (
router_info[lib_constants.INTERFACE_KEY][1]['address_scopes'] = (
address_scope2)
router = self.manage_router(self.agent, router_info)
@ -356,7 +356,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
(machine_same_scope, machine_diff_scope,
router) = self._setup_address_scope('scope1', 'scope2', 'scope1')
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[lib_constants.FLOATINGIP_KEY] = []
fip_same_scope = '19.4.4.10'
self._add_fip(router, fip_same_scope,
fixed_address=machine_same_scope.ip,
@ -399,7 +399,7 @@ class L3AgentTestCase(framework.L3AgentTestFramework):
(machine_same_scope, machine_diff_scope,
router) = self._setup_address_scope('scope1', 'scope2', 'scope1')
router.router[l3_constants.FLOATINGIP_KEY] = []
router.router[lib_constants.FLOATINGIP_KEY] = []
fip = '19.4.4.11'
self._add_fip(router, fip,
fixed_address=machine_diff_scope.ip,

3
neutron/tests/functional/agent/test_dhcp_agent.py
View File

@ -32,7 +32,6 @@ from neutron.agent.linux import external_process
from neutron.agent.linux import interface
from neutron.agent.linux import ip_lib
from neutron.agent.linux import utils
from neutron.common import constants
from neutron.common import utils as common_utils
from neutron.tests.common import net_helpers
from neutron.tests.functional.agent.linux import helpers
@ -112,7 +111,7 @@ class DHCPAgentOVSTestFramework(base.BaseSudoTestCase):
"ipv6_ra_mode": None,
"ipv6_address_mode": None})
if ip_version == 6:
sn_dict['ipv6_address_mode'] = constants.DHCPV6_STATEFUL
sn_dict['ipv6_address_mode'] = lib_const.DHCPV6_STATEFUL
return sn_dict
def create_port_dict(self, network_id, subnet_id, mac_address,

12
neutron/tests/functional/scheduler/test_l3_agent_scheduler.py
View File

@ -16,12 +16,10 @@
import collections
import random
from neutron_lib import constants
from oslo_utils import uuidutils
import testscenarios
from oslo_utils import uuidutils
from neutron.api.v2 import attributes
from neutron.common import constants
from neutron import context
from neutron.db import external_net_db
from neutron.scheduler import l3_agent_scheduler
@ -613,9 +611,9 @@ class L3DVRSchedulerBaseTest(L3SchedulerBaseTest):
'enable_dhcp': False,
'gateway_ip': gw_ip,
'shared': False,
'allocation_pools': attributes.ATTR_NOT_SPECIFIED,
'dns_nameservers': attributes.ATTR_NOT_SPECIFIED,
'host_routes': attributes.ATTR_NOT_SPECIFIED}
'allocation_pools': constants.ATTR_NOT_SPECIFIED,
'dns_nameservers': constants.ATTR_NOT_SPECIFIED,
'host_routes': constants.ATTR_NOT_SPECIFIED}
return self.plugin.create_subnet(self.adminContext, {'subnet': subnet})

5
neutron/tests/functional/services/l3_router/test_l3_dvr_ha_router_plugin.py
View File

@ -15,7 +15,6 @@
import mock
from neutron_lib import constants
from neutron.common import constants as n_const
from neutron.common import topics
from neutron.extensions import external_net
from neutron.extensions import l3_ext_ha_mode
@ -32,7 +31,7 @@ class L3DvrHATestCase(test_l3_dvr_router_plugin.L3DvrTestCase):
super(L3DvrHATestCase, self).setUp()
self.l3_agent_2 = helpers.register_l3_agent(
host="standby",
agent_mode=n_const.L3_AGENT_MODE_DVR_SNAT)
agent_mode=constants.L3_AGENT_MODE_DVR_SNAT)
def _create_router(self, distributed=True, ha=True):
return (super(L3DvrHATestCase, self).
@ -136,7 +135,7 @@ class L3DvrHATestCase(test_l3_dvr_router_plugin.L3DvrTestCase):
HOST1, HOST2, HOST3 = 'host1', 'host2', 'host3'
for host in [HOST1, HOST2, HOST3]:
helpers.register_l3_agent(
host=host, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=host, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router(distributed=True, ha=True)
arg_list = (portbindings.HOST_ID,)

29
neutron/tests/functional/services/l3_router/test_l3_dvr_router_plugin.py
View File

@ -16,7 +16,6 @@ import mock
from neutron_lib import constants
from neutron.api.rpc.handlers import l3_rpc
from neutron.common import constants as n_const
from neutron.common import topics
from neutron import context
from neutron.extensions import external_net
@ -32,7 +31,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def setUp(self):
super(L3DvrTestCase, self).setUp()
self.l3_agent = helpers.register_l3_agent(
agent_mode=n_const.L3_AGENT_MODE_DVR_SNAT)
agent_mode=constants.L3_AGENT_MODE_DVR_SNAT)
def _create_router(self, distributed=True, ha=False):
return (super(L3DvrTestCase, self).
@ -283,9 +282,9 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
{'port': {portbindings.HOST_ID: 'host2'}})
# and create l3 agents on corresponding hosts
helpers.register_l3_agent(host='host1',
agent_mode=n_const.L3_AGENT_MODE_DVR)
agent_mode=constants.L3_AGENT_MODE_DVR)
helpers.register_l3_agent(host='host2',
agent_mode=n_const.L3_AGENT_MODE_DVR)
agent_mode=constants.L3_AGENT_MODE_DVR)
# make net external
ext_net_id = ext_subnet['subnet']['network_id']
@ -456,7 +455,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def test_allowed_addr_pairs_arp_update_for_port_with_original_owner(self):
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
private_net1 = self._make_network(self.fmt, 'net1', True)
test_allocation_pools = [{'start': '10.1.0.2',
@ -551,10 +550,10 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def test_allowed_addr_pairs_delayed_fip_and_update_arp_entry(self):
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
HOST2 = 'host2'
helpers.register_l3_agent(
host=HOST2, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST2, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
private_net1 = self._make_network(self.fmt, 'net1', True)
test_allocation_pools = [{'start': '10.1.0.2',
@ -692,7 +691,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def test_allowed_address_pairs_update_arp_entry(self):
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
private_net1 = self._make_network(self.fmt, 'net1', True)
test_allocation_pools = [{'start': '10.1.0.2',
@ -798,7 +797,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def test_update_service_port_with_allowed_address_pairs(self):
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
private_net1 = self._make_network(self.fmt, 'net1', True)
test_allocation_pools = [{'start': '10.1.0.2',
@ -937,10 +936,10 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
# register l3 agents in dvr mode in addition to existing dvr_snat agent
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
HOST2 = 'host2'
helpers.register_l3_agent(
host=HOST2, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST2, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
with self.subnet() as subnet:
self.l3_plugin.add_router_interface(
@ -1036,7 +1035,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
HOST = 'host1'
non_admin_tenant = 'tenant1'
helpers.register_l3_agent(
host=HOST, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
with self.network(shared=True) as net,\
self.subnet(network=net) as subnet,\
@ -1082,7 +1081,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
HOST1, HOST2 = 'host1', 'host2'
for host in [HOST1, HOST2]:
helpers.register_l3_agent(
host=host, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=host, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
arg_list = (portbindings.HOST_ID,)
@ -1153,7 +1152,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
HOST1, HOST2, HOST3 = 'host1', 'host2', 'host3'
for host in [HOST1, HOST2, HOST3]:
helpers.register_l3_agent(
host=host, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=host, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
arg_list = (portbindings.HOST_ID,)
@ -1494,7 +1493,7 @@ class L3DvrTestCase(ml2_test_base.ML2TestFramework):
def test_remove_router_interface(self):
HOST1 = 'host1'
helpers.register_l3_agent(
host=HOST1, agent_mode=n_const.L3_AGENT_MODE_DVR)
host=HOST1, agent_mode=constants.L3_AGENT_MODE_DVR)
router = self._create_router()
arg_list = (portbindings.HOST_ID,)
with self.subnet() as subnet,\

2
neutron/tests/tools.py
View File

@ -298,7 +298,7 @@ def reset_random_seed():
def get_random_ipv6_mode():
return random.choice(n_const.IPV6_MODES)
return random.choice(constants.IPV6_MODES)
import_modules_recursively = moves.moved_function(

150
neutron/tests/unit/agent/l3/test_agent.py
View File

@ -20,7 +20,7 @@ from itertools import combinations as iter_combinations
import eventlet
import mock
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions as exc
from oslo_config import cfg
from oslo_log import log
@ -151,7 +151,7 @@ class BasicRouterOperationsFramework(base.BaseTestCase):
'id': subnet_id_1}],
'network_id': _uuid(),
'device_owner':
l3_constants.DEVICE_OWNER_ROUTER_SNAT,
lib_constants.DEVICE_OWNER_ROUTER_SNAT,
'mac_address': 'fa:16:3e:80:8d:80',
'fixed_ips': [{'subnet_id': subnet_id_1,
'ip_address': '152.2.0.13',
@ -162,7 +162,7 @@ class BasicRouterOperationsFramework(base.BaseTestCase):
'id': subnet_id_2}],
'network_id': _uuid(),
'device_owner':
l3_constants.DEVICE_OWNER_ROUTER_SNAT,
lib_constants.DEVICE_OWNER_ROUTER_SNAT,
'mac_address': 'fa:16:3e:80:8d:80',
'fixed_ips': [{'subnet_id': subnet_id_2,
'ip_address': '152.10.0.13',
@ -433,7 +433,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'floating_ip_address': '192.168.1.34',
'fixed_ip_address': '192.168.0.1',
'port_id': _uuid()}]}
router[l3_constants.FLOATINGIP_KEY] = fake_fip['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_fip['floatingips']
ri.external_gateway_added(ex_gw_port, interface_name)
if not router.get('distributed'):
self.assertEqual(1, self.mock_driver.plug.call_count)
@ -581,7 +581,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'floating_ip_address': '192.168.1.34',
'fixed_ip_address': '192.168.0.1',
'port_id': _uuid()}]}
router[l3_constants.FLOATINGIP_KEY] = fake_fip['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_fip['floatingips']
ri.external_gateway_updated(ex_gw_port, interface_name)
self.assertEqual(1, self.mock_driver.plug.call_count)
self.assertEqual(1, self.mock_driver.init_router_port.call_count)
@ -783,7 +783,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def _verify_snat_mangle_rules(self, nat_rules, mangle_rules, router,
negate=False):
interfaces = router[l3_constants.INTERFACE_KEY]
interfaces = router[lib_constants.INTERFACE_KEY]
source_cidrs = []
for iface in interfaces:
for subnet in iface['subnets']:
@ -830,9 +830,9 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
test_port = {
'mac_address': '00:12:23:34:45:56',
'fixed_ips': [{'subnet_id': l3_test_common.get_subnet_id(
router[l3_constants.INTERFACE_KEY][0]),
router[lib_constants.INTERFACE_KEY][0]),
'ip_address': '101.12.13.14'}]}
internal_ports = ri.router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = ri.router.get(lib_constants.INTERFACE_KEY, [])
# test valid case
with mock.patch.object(ri, 'get_snat_interfaces') as get_interfaces:
get_interfaces.return_value = [test_port]
@ -859,7 +859,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
router,
**self.ri_kwargs)
subnet_id = l3_test_common.get_subnet_id(
router[l3_constants.INTERFACE_KEY][0])
router[lib_constants.INTERFACE_KEY][0])
ri.router['distributed'] = True
ri.router['_snat_router_interfaces'] = [{
'fixed_ips': [{'subnet_id': subnet_id,
@ -896,7 +896,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
fake_floatingips2 = copy.deepcopy(fake_floatingips1)
fake_floatingips2['floatingips'][0]['fixed_ip_address'] = '7.7.7.8'
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips2['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips2['floatingips']
ri.process(agent)
ri.process_floating_ip_addresses.assert_called_with(mock.ANY)
ri.process_floating_ip_addresses.reset_mock()
@ -921,7 +921,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
self.assertEqual(1, ri.external_gateway_updated.call_count)
# remove just the floating ips
del router[l3_constants.FLOATINGIP_KEY]
del router[lib_constants.FLOATINGIP_KEY]
ri.process(agent)
ri.process_floating_ip_addresses.assert_called_with(mock.ANY)
ri.process_floating_ip_addresses.reset_mock()
@ -929,7 +929,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
ri.process_floating_ip_nat_rules.reset_mock()
# now no ports so state is torn down
del router[l3_constants.INTERFACE_KEY]
del router[lib_constants.INTERFACE_KEY]
del router['gw_port']
ri.process(agent)
self.assertEqual(1, self.send_adv_notif.call_count)
@ -946,14 +946,14 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
ex_gw_port = {'id': _uuid(), 'network_id': mock.sentinel.ext_net_id}
ri.add_floating_ip = mock.Mock(
return_value=l3_constants.FLOATINGIP_STATUS_ACTIVE)
return_value=lib_constants.FLOATINGIP_STATUS_ACTIVE)
with mock.patch.object(lla.LinkLocalAllocator, '_write'):
if ri.router['distributed']:
ri.fip_ns = agent.get_fip_ns(ex_gw_port['network_id'])
ri.create_dvr_fip_interfaces(ex_gw_port)
fip_statuses = ri.process_floating_ip_addresses(
mock.sentinel.interface_name)
self.assertEqual({fip_id: l3_constants.FLOATINGIP_STATUS_ACTIVE},
self.assertEqual({fip_id: lib_constants.FLOATINGIP_STATUS_ACTIVE},
fip_statuses)
ri.add_floating_ip.assert_called_once_with(
floating_ips[0], mock.sentinel.interface_name, device)
@ -984,7 +984,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
)
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port
router['distributed'] = True
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1050,7 +1050,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
)
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[n_const.FLOATINGIP_AGENT_INTF_KEY] = []
router['distributed'] = True
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1095,7 +1095,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
)
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port
router['distributed'] = True
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1146,7 +1146,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
)
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[n_const.FLOATINGIP_AGENT_INTF_KEY] = agent_gateway_port
router['distributed'] = True
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1182,7 +1182,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'host': HOSTNAME}]}
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs)
ri.iptables_manager.ipv4['nat'] = mock.MagicMock()
@ -1409,7 +1409,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def test_process_router_ipv6_slaac_interface_added(self):
router = l3_test_common.prepare_router_data()
ri = self._process_router_ipv6_interface_added(
router, ra_mode=n_const.IPV6_SLAAC)
router, ra_mode=lib_constants.IPV6_SLAAC)
self._assert_ri_process_enabled(ri)
# Expect radvd configured with prefix
radvd_config_str = self.utils_replace_file.call_args[0][1]
@ -1419,7 +1419,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def test_process_router_ipv6_dhcpv6_stateful_interface_added(self):
router = l3_test_common.prepare_router_data()
ri = self._process_router_ipv6_interface_added(
router, ra_mode=n_const.DHCPV6_STATEFUL)
router, ra_mode=lib_constants.DHCPV6_STATEFUL)
self._assert_ri_process_enabled(ri)
# Expect radvd configured with prefix
radvd_config_str = self.utils_replace_file.call_args[0][1]
@ -1429,12 +1429,12 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def test_process_router_ipv6_subnets_added(self):
router = l3_test_common.prepare_router_data()
ri = self._process_router_ipv6_subnet_added(router, ipv6_subnet_modes=[
{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC},
{'ra_mode': n_const.DHCPV6_STATELESS,
'address_mode': n_const.DHCPV6_STATELESS},
{'ra_mode': n_const.DHCPV6_STATEFUL,
'address_mode': n_const.DHCPV6_STATEFUL}])
{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC},
{'ra_mode': lib_constants.DHCPV6_STATELESS,
'address_mode': lib_constants.DHCPV6_STATELESS},
{'ra_mode': lib_constants.DHCPV6_STATEFUL,
'address_mode': lib_constants.DHCPV6_STATEFUL}])
self._assert_ri_process_enabled(ri)
radvd_config_str = self.utils_replace_file.call_args[0][1]
# Assert we have a prefix from IPV6_SLAAC and a prefix from
@ -1454,8 +1454,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
l3_test_common.router_append_subnet(
router, count=1,
ip_version=6, ipv6_subnet_modes=[
{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}])
{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}])
self._process_router_instance_for_agent(agent, ri, router)
self._assert_ri_process_enabled(ri)
radvd_config = self.utils_replace_file.call_args[0][1].split()
@ -1468,13 +1468,13 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
self.external_process.reset_mock()
self.utils_replace_file.reset_mock()
# Add the second subnet on the same interface
interface_id = router[l3_constants.INTERFACE_KEY][1]['id']
interface_id = router[lib_constants.INTERFACE_KEY][1]['id']
l3_test_common.router_append_subnet(
router, count=1,
ip_version=6,
ipv6_subnet_modes=[
{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}],
{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}],
interface_id=interface_id)
self._process_router_instance_for_agent(agent, ri, router)
# radvd should have been enabled again and the interface
@ -1508,7 +1508,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# Process with NAT
ri.process(agent)
# Add an interface and reprocess
del router[l3_constants.INTERFACE_KEY][1]
del router[lib_constants.INTERFACE_KEY][1]
# Reassign the router object to RouterInfo
ri.router = router
ri.process(agent)
@ -1529,7 +1529,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
self.external_process.reset_mock()
self.process_monitor.reset_mock()
# Remove the IPv6 interface and reprocess
del router[l3_constants.INTERFACE_KEY][1]
del router[lib_constants.INTERFACE_KEY][1]
self._process_router_instance_for_agent(agent, ri, router)
self._assert_ri_process_disabled(ri)
@ -1542,8 +1542,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# Add an IPv6 interface with two subnets and reprocess
l3_test_common.router_append_subnet(
router, count=2, ip_version=6,
ipv6_subnet_modes=([{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}]
ipv6_subnet_modes=([{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}]
* 2))
self._process_router_instance_for_agent(agent, ri, router)
self._assert_ri_process_enabled(ri)
@ -1551,10 +1551,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
self.utils_replace_file.reset_mock()
self.external_process.reset_mock()
# Remove one subnet from the interface and reprocess
interfaces = copy.deepcopy(router[l3_constants.INTERFACE_KEY])
interfaces = copy.deepcopy(router[lib_constants.INTERFACE_KEY])
del interfaces[1]['subnets'][0]
del interfaces[1]['fixed_ips'][0]
router[l3_constants.INTERFACE_KEY] = interfaces
router[lib_constants.INTERFACE_KEY] = interfaces
self._process_router_instance_for_agent(agent, ri, router)
# Assert radvd was enabled again and that we only have one
# prefix on the interface
@ -1578,7 +1578,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
internal_network_added.side_effect = RuntimeError
self.assertRaises(RuntimeError, ri.process, agent)
self.assertNotIn(
router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
router[lib_constants.INTERFACE_KEY][0], ri.internal_ports)
# The unexpected exception has been fixed manually
internal_network_added.side_effect = None
@ -1588,7 +1588,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
ri.process(agent)
# We were able to add the port to ri.internal_ports
self.assertIn(
router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
router[lib_constants.INTERFACE_KEY][0], ri.internal_ports)
def test_process_router_internal_network_removed_unexpected_error(self):
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1608,7 +1608,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# The above port is set to down state, remove it.
self.assertRaises(RuntimeError, ri.process, agent)
self.assertIn(
router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
router[lib_constants.INTERFACE_KEY][0], ri.internal_ports)
# The unexpected exception has been fixed manually
internal_net_removed.side_effect = None
@ -1618,18 +1618,18 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
ri.process(agent)
# We were able to remove the port from ri.internal_ports
self.assertNotIn(
router[l3_constants.INTERFACE_KEY][0], ri.internal_ports)
router[lib_constants.INTERFACE_KEY][0], ri.internal_ports)
def test_process_router_floatingip_nochange(self):
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
router = l3_test_common.prepare_router_data(num_internal_ports=1)
fip1 = {'id': _uuid(), 'floating_ip_address': '8.8.8.8',
'fixed_ip_address': '7.7.7.7', 'status': 'ACTIVE',
'port_id': router[l3_constants.INTERFACE_KEY][0]['id']}
'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}
fip2 = copy.copy(fip1)
fip2.update({'id': _uuid(), 'status': 'DOWN',
'floating_ip_address': '9.9.9.9'})
router[l3_constants.FLOATINGIP_KEY] = [fip1, fip2]
router[lib_constants.FLOATINGIP_KEY] = [fip1, fip2]
ri = legacy_router.LegacyRouter(router['id'], router,
**self.ri_kwargs)
@ -1650,10 +1650,10 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
router = l3_test_common.prepare_router_data(num_internal_ports=1)
fip1 = {'id': _uuid(), 'floating_ip_address': '8.8.8.8',
'fixed_ip_address': '7.7.7.7', 'status': 'ACTIVE',
'port_id': router[l3_constants.INTERFACE_KEY][0]['id']}
'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}
fip2 = copy.copy(fip1)
fip2.update({'id': _uuid(), 'status': 'DOWN', })
router[l3_constants.FLOATINGIP_KEY] = [fip1, fip2]
router[lib_constants.FLOATINGIP_KEY] = [fip1, fip2]
ri = legacy_router.LegacyRouter(router['id'], router,
**self.ri_kwargs)
@ -1676,12 +1676,12 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'update_floatingip_statuses') as mock_update_fip_status:
fip_id = _uuid()
router = l3_test_common.prepare_router_data(num_internal_ports=1)
router[l3_constants.FLOATINGIP_KEY] = [
router[lib_constants.FLOATINGIP_KEY] = [
{'id': fip_id,
'floating_ip_address': '8.8.8.8',
'fixed_ip_address': '7.7.7.7',
'status': 'DOWN',
'port_id': router[l3_constants.INTERFACE_KEY][0]['id']}]
'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}]
ri = legacy_router.LegacyRouter(router['id'],
router,
@ -1691,16 +1691,16 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# Assess the call for putting the floating IP up was performed
mock_update_fip_status.assert_called_once_with(
mock.ANY, ri.router_id,
{fip_id: l3_constants.FLOATINGIP_STATUS_ACTIVE})
{fip_id: lib_constants.FLOATINGIP_STATUS_ACTIVE})
mock_update_fip_status.reset_mock()
# Process the router again, this time without floating IPs
router[l3_constants.FLOATINGIP_KEY] = []
router[lib_constants.FLOATINGIP_KEY] = []
ri.router = router
ri.process(agent)
# Assess the call for putting the floating IP up was performed
mock_update_fip_status.assert_called_once_with(
mock.ANY, ri.router_id,
{fip_id: l3_constants.FLOATINGIP_STATUS_DOWN})
{fip_id: lib_constants.FLOATINGIP_STATUS_DOWN})
def test_process_router_floatingip_exception(self):
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1709,11 +1709,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'update_floatingip_statuses') as mock_update_fip_status:
fip_id = _uuid()
router = l3_test_common.prepare_router_data(num_internal_ports=1)
router[l3_constants.FLOATINGIP_KEY] = [
router[lib_constants.FLOATINGIP_KEY] = [
{'id': fip_id,
'floating_ip_address': '8.8.8.8',
'fixed_ip_address': '7.7.7.7',
'port_id': router[l3_constants.INTERFACE_KEY][0]['id']}]
'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}]
ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs)
ri.process_floating_ip_addresses = mock.Mock(
@ -1724,7 +1724,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# was performed
mock_update_fip_status.assert_called_once_with(
mock.ANY, ri.router_id,
{fip_id: l3_constants.FLOATINGIP_STATUS_ERROR})
{fip_id: lib_constants.FLOATINGIP_STATUS_ERROR})
def test_process_external_iptables_exception(self):
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
@ -1733,11 +1733,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
'update_floatingip_statuses') as mock_update_fip_status:
fip_id = _uuid()
router = l3_test_common.prepare_router_data(num_internal_ports=1)
router[l3_constants.FLOATINGIP_KEY] = [
router[lib_constants.FLOATINGIP_KEY] = [
{'id': fip_id,
'floating_ip_address': '8.8.8.8',
'fixed_ip_address': '7.7.7.7',
'port_id': router[l3_constants.INTERFACE_KEY][0]['id']}]
'port_id': router[lib_constants.INTERFACE_KEY][0]['id']}]
ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs)
ri.iptables_manager._apply = mock.Mock(side_effect=Exception)
@ -1746,7 +1746,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
# was performed
mock_update_fip_status.assert_called_once_with(
mock.ANY, ri.router_id,
{fip_id: l3_constants.FLOATINGIP_STATUS_ERROR})
{fip_id: lib_constants.FLOATINGIP_STATUS_ERROR})
self.assertEqual(1, ri.iptables_manager._apply.call_count)
@ -1829,7 +1829,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
num_internal_ports=1)
ri = l3router.RouterInfo(router['id'], router, **self.ri_kwargs)
internal_ports = ri.router.get(l3_constants.INTERFACE_KEY, [])
internal_ports = ri.router.get(lib_constants.INTERFACE_KEY, [])
self.assertEqual(1, len(internal_ports))
internal_port = internal_ports[0]
@ -2360,8 +2360,8 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def test_generate_radvd_mtu_conf(self):
router = l3_test_common.prepare_router_data()
ipv6_subnet_modes = [{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}]
ipv6_subnet_modes = [{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}]
network_mtu = '1446'
ri = self._process_router_ipv6_subnet_added(router,
ipv6_subnet_modes,
@ -2369,22 +2369,22 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
network_mtu)
expected = "AdvLinkMTU 1446"
ri.agent_conf.set_override('advertise_mtu', False)
ri.radvd._generate_radvd_conf(router[l3_constants.INTERFACE_KEY])
ri.radvd._generate_radvd_conf(router[lib_constants.INTERFACE_KEY])
self.assertNotIn(expected, self.utils_replace_file.call_args[0][1])
# Verify that MTU is advertised when advertise_mtu is True
ri.agent_conf.set_override('advertise_mtu', True)
ri.radvd._generate_radvd_conf(router[l3_constants.INTERFACE_KEY])
ri.radvd._generate_radvd_conf(router[lib_constants.INTERFACE_KEY])
self.assertIn(expected, self.utils_replace_file.call_args[0][1])
def test_generate_radvd_conf_other_and_managed_flag(self):
# expected = {ra_mode: (AdvOtherConfigFlag, AdvManagedFlag), ...}
expected = {n_const.IPV6_SLAAC: (False, False),
n_const.DHCPV6_STATELESS: (True, False),
n_const.DHCPV6_STATEFUL: (False, True)}
expected = {lib_constants.IPV6_SLAAC: (False, False),
lib_constants.DHCPV6_STATELESS: (True, False),
lib_constants.DHCPV6_STATEFUL: (False, True)}
modes = [n_const.IPV6_SLAAC, n_const.DHCPV6_STATELESS,
n_const.DHCPV6_STATEFUL]
modes = [lib_constants.IPV6_SLAAC, lib_constants.DHCPV6_STATELESS,
lib_constants.DHCPV6_STATEFUL]
mode_combos = list(iter_chain(*[[list(combo) for combo in
iter_combinations(modes, i)] for i in range(1, len(modes) + 1)]))
@ -2395,7 +2395,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
ri = self._process_router_ipv6_subnet_added(router,
ipv6_subnet_modes)
ri.radvd._generate_radvd_conf(router[l3_constants.INTERFACE_KEY])
ri.radvd._generate_radvd_conf(router[lib_constants.INTERFACE_KEY])
def assertFlag(flag):
return (self.assertIn if flag else self.assertNotIn)
@ -2413,11 +2413,11 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
self.conf.set_override('min_rtr_adv_interval', 22)
self.conf.set_override('max_rtr_adv_interval', 66)
router = l3_test_common.prepare_router_data()
ipv6_subnet_modes = [{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}]
ipv6_subnet_modes = [{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}]
ri = self._process_router_ipv6_subnet_added(router,
ipv6_subnet_modes)
ri.radvd._generate_radvd_conf(router[l3_constants.INTERFACE_KEY])
ri.radvd._generate_radvd_conf(router[lib_constants.INTERFACE_KEY])
self.assertIn("MinRtrAdvInterval 22",
self.utils_replace_file.call_args[0][1])
self.assertIn("MaxRtrAdvInterval 66",
@ -2425,13 +2425,13 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
def test_generate_radvd_rdnss_conf(self):
router = l3_test_common.prepare_router_data()
ipv6_subnet_modes = [{'ra_mode': n_const.IPV6_SLAAC,
'address_mode': n_const.IPV6_SLAAC}]
ipv6_subnet_modes = [{'ra_mode': lib_constants.IPV6_SLAAC,
'address_mode': lib_constants.IPV6_SLAAC}]
dns_list = ['fd01:1::100', 'fd01:1::200', 'fd01::300', 'fd01::400']
ri = self._process_router_ipv6_subnet_added(router,
ipv6_subnet_modes,
dns_nameservers=dns_list)
ri.radvd._generate_radvd_conf(router[l3_constants.INTERFACE_KEY])
ri.radvd._generate_radvd_conf(router[lib_constants.INTERFACE_KEY])
# Verify that radvd configuration file includes RDNSS entries
expected = "RDNSS "
for dns in dns_list[0:ra.MAX_RDNSS_ENTRIES]:
@ -2512,7 +2512,7 @@ class TestBasicRouterOperations(BasicRouterOperationsFramework):
expected_calls = []
for intf in intfs:
# Remove the router interface
router[l3_constants.INTERFACE_KEY].remove(intf)
router[lib_constants.INTERFACE_KEY].remove(intf)
requestor_id = self._pd_get_requestor_id(intf, router, ri)
expected_calls += (self._pd_expected_call_external_process(
requestor_id, ri, False))

24
neutron/tests/unit/agent/l3/test_dvr_local_router.py
View File

@ -14,7 +14,7 @@
import mock
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_config import cfg
from oslo_log import log
from oslo_utils import uuidutils
@ -125,7 +125,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
'id': subnet_id_1}],
'network_id': _uuid(),
'device_owner':
l3_constants.DEVICE_OWNER_ROUTER_SNAT,
lib_constants.DEVICE_OWNER_ROUTER_SNAT,
'mac_address': 'fa:16:3e:80:8d:80',
'fixed_ips': [{'subnet_id': subnet_id_1,
'ip_address': '152.2.0.13',
@ -136,7 +136,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
'id': subnet_id_2}],
'network_id': _uuid(),
'device_owner':
l3_constants.DEVICE_OWNER_ROUTER_SNAT,
lib_constants.DEVICE_OWNER_ROUTER_SNAT,
'mac_address': 'fa:16:3e:80:8d:80',
'fixed_ips': [{'subnet_id': subnet_id_2,
'ip_address': '152.10.0.13',
@ -320,7 +320,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
fip = {'floating_ip_address': ip}
result = self._test_add_floating_ip(ri, fip, True)
ri.floating_ip_added_dist.assert_called_once_with(fip, ip + '/32')
self.assertEqual(l3_constants.FLOATINGIP_STATUS_ACTIVE, result)
self.assertEqual(lib_constants.FLOATINGIP_STATUS_ACTIVE, result)
@mock.patch.object(router_info.RouterInfo, 'remove_floating_ip')
def test_remove_floating_ip(self, super_remove_floating_ip):
@ -375,10 +375,10 @@ class TestDvrRouterOperations(base.BaseTestCase):
router['distributed'] = True
ri = dvr_router.DvrLocalRouter(
agent, HOSTNAME, router['id'], router, **self.ri_kwargs)
ports = ri.router.get(l3_constants.INTERFACE_KEY, [])
ports = ri.router.get(lib_constants.INTERFACE_KEY, [])
subnet_id = l3_test_common.get_subnet_id(ports[0])
test_ports = [{'mac_address': '00:11:22:33:44:55',
'device_owner': l3_constants.DEVICE_OWNER_DHCP,
'device_owner': lib_constants.DEVICE_OWNER_DHCP,
'fixed_ips': [{'ip_address': '1.2.3.4',
'prefixlen': 24,
'subnet_id': subnet_id}]}]
@ -405,7 +405,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
router = l3_test_common.prepare_router_data(num_internal_ports=2)
router['distributed'] = True
subnet_id = l3_test_common.get_subnet_id(
router[l3_constants.INTERFACE_KEY][0])
router[lib_constants.INTERFACE_KEY][0])
arp_table = {'ip_address': '1.7.23.11',
'mac_address': '00:11:22:33:44:55',
'subnet_id': subnet_id}
@ -421,7 +421,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
router = l3_test_common.prepare_router_data(num_internal_ports=2)
subnet_id = l3_test_common.get_subnet_id(
router[l3_constants.INTERFACE_KEY][0])
router[lib_constants.INTERFACE_KEY][0])
arp_table = {'ip_address': '1.7.23.11',
'mac_address': '00:11:22:33:44:55',
'subnet_id': subnet_id}
@ -447,7 +447,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
ri = dvr_router.DvrLocalRouter(
agent, HOSTNAME, router['id'], router, **self.ri_kwargs)
subnet_id = l3_test_common.get_subnet_id(
ri.router[l3_constants.INTERFACE_KEY][0])
ri.router[lib_constants.INTERFACE_KEY][0])
return ri, subnet_id
def test__update_arp_entry_calls_arp_cache_with_no_device(self):
@ -487,7 +487,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
router = l3_test_common.prepare_router_data(num_internal_ports=2)
router['distributed'] = True
subnet_id = l3_test_common.get_subnet_id(
router[l3_constants.INTERFACE_KEY][0])
router[lib_constants.INTERFACE_KEY][0])
arp_table = {'ip_address': '1.5.25.15',
'mac_address': '00:44:33:22:11:55',
'subnet_id': subnet_id}
@ -514,7 +514,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
'gateway_ip': '20.0.0.1'}],
'id': _uuid(),
portbindings.HOST_ID: 'myhost',
'device_owner': l3_constants.DEVICE_OWNER_AGENT_GW,
'device_owner': lib_constants.DEVICE_OWNER_AGENT_GW,
'network_id': fake_network_id,
'mac_address': 'ca:fe:de:ad:be:ef'}]
)
@ -545,7 +545,7 @@ class TestDvrRouterOperations(base.BaseTestCase):
'port_id': _uuid()}]}
router = l3_test_common.prepare_router_data(enable_snat=True)
router[l3_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router[lib_constants.FLOATINGIP_KEY] = fake_floatingips['floatingips']
router['distributed'] = True
agent = l3_agent.L3NATAgent(HOSTNAME, self.conf)
ri = dvr_router.DvrLocalRouter(agent,

10
neutron/tests/unit/agent/l3/test_legacy_router.py
View File

@ -13,7 +13,7 @@
# under the License.
import mock
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_utils import uuidutils
from neutron.agent.l3 import legacy_router
@ -78,9 +78,9 @@ class TestBasicRouterOperations(BasicRouterTestCaseFramework):
ri.external_gateway_removed(ex_gw_port, "qg-fake-name")
cidr_pri = '%s/%s' % (gw_ip_pri, v4_prefixlen)
cidr_sec = '%s/%s' % (gw_ip_sec, l3_constants.IPv4_BITS)
cidr_sec = '%s/%s' % (gw_ip_sec, lib_constants.IPv4_BITS)
cidr_v6 = '%s/%s' % (gw_ip6_pri, v6_prefixlen)
cidr_v6_sec = '%s/%s' % (gw_ip6_sec, l3_constants.IPv6_BITS)
cidr_v6_sec = '%s/%s' % (gw_ip6_sec, lib_constants.IPv6_BITS)
device.delete_addr_and_conntrack_state.assert_has_calls(
[mock.call(cidr_pri), mock.call(cidr_sec),
@ -101,7 +101,7 @@ class TestAddFloatingIpWithMockGarp(BasicRouterTestCaseFramework):
mock.sentinel.interface_name,
ip,
self.agent_conf)
self.assertEqual(l3_constants.FLOATINGIP_STATUS_ACTIVE, result)
self.assertEqual(lib_constants.FLOATINGIP_STATUS_ACTIVE, result)
def test_add_floating_ip_error(self, send_ip_addr_adv_notif):
ri = self._create_router()
@ -110,4 +110,4 @@ class TestAddFloatingIpWithMockGarp(BasicRouterTestCaseFramework):
mock.sentinel.interface_name,
mock.sentinel.device)
self.assertFalse(ip_lib.send_ip_addr_adv_notif.called)
self.assertEqual(l3_constants.FLOATINGIP_STATUS_ERROR, result)
self.assertEqual(lib_constants.FLOATINGIP_STATUS_ERROR, result)

18
neutron/tests/unit/agent/l3/test_router_info.py
View File

@ -11,7 +11,7 @@
# under the License.
import mock
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from oslo_utils import uuidutils
from neutron.agent.common import config as agent_config
@ -127,7 +127,7 @@ class TestRouterInfo(base.BaseTestCase):
port = {
'id': _uuid(),
'fixed_ips': [{'ip_address': '172.9.9.9'}],
'address_scopes': {l3_constants.IP_VERSION_4: '1234'}
'address_scopes': {lib_constants.IP_VERSION_4: '1234'}
}
ipv4_mangle = ri.iptables_manager.ipv4['mangle'] = mock.MagicMock()
ri.get_address_scope_mark_mask = mock.Mock(return_value='fake_mark')
@ -137,7 +137,7 @@ class TestRouterInfo(base.BaseTestCase):
ri.process_floating_ip_address_scope_rules = mock.Mock()
ri.iptables_manager._apply = mock.Mock()
ri.router[l3_constants.INTERFACE_KEY] = [port]
ri.router[lib_constants.INTERFACE_KEY] = [port]
ri.process_address_scope()
ipv4_mangle.add_rule.assert_called_once_with(
@ -338,8 +338,8 @@ class TestBasicRouterOperations(BasicRouterTestCaseFramework):
statuses = ri.put_fips_in_error_state()
expected = [{mock.sentinel.id1: l3_constants.FLOATINGIP_STATUS_ERROR,
mock.sentinel.id2: l3_constants.FLOATINGIP_STATUS_ERROR}]
expected = [{mock.sentinel.id1: lib_constants.FLOATINGIP_STATUS_ERROR,
mock.sentinel.id2: lib_constants.FLOATINGIP_STATUS_ERROR}]
self.assertNotEqual(expected, statuses)
def test_configure_fip_addresses(self):
@ -372,7 +372,7 @@ class TestFloatingIpWithMockDevice(BasicRouterTestCaseFramework):
'id': fip_id, 'port_id': _uuid(),
'floating_ip_address': '15.1.2.3',
'fixed_ip_address': '192.168.0.2',
'status': l3_constants.FLOATINGIP_STATUS_DOWN
'status': lib_constants.FLOATINGIP_STATUS_DOWN
}
IPDevice.return_value = device = mock.Mock()
@ -382,7 +382,7 @@ class TestFloatingIpWithMockDevice(BasicRouterTestCaseFramework):
fip_statuses = ri.process_floating_ip_addresses(
mock.sentinel.interface_name)
self.assertEqual({fip_id: l3_constants.FLOATINGIP_STATUS_ACTIVE},
self.assertEqual({fip_id: lib_constants.FLOATINGIP_STATUS_ACTIVE},
fip_statuses)
self.assertFalse(device.addr.add.called)
@ -417,13 +417,13 @@ class TestFloatingIpWithMockDevice(BasicRouterTestCaseFramework):
}
ri = self._create_router()
ri.add_floating_ip = mock.Mock(
return_value=l3_constants.FLOATINGIP_STATUS_ERROR)
return_value=lib_constants.FLOATINGIP_STATUS_ERROR)
ri.get_floating_ips = mock.Mock(return_value=[fip])
fip_statuses = ri.process_floating_ip_addresses(
mock.sentinel.interface_name)
self.assertEqual({fip_id: l3_constants.FLOATINGIP_STATUS_ERROR},
self.assertEqual({fip_id: lib_constants.FLOATINGIP_STATUS_ERROR},
fip_statuses)
# TODO(mrsmith): refactor for DVR cases

8
neutron/tests/unit/agent/linux/test_dhcp.py
View File

@ -465,7 +465,7 @@ class FakeV6SubnetDHCPStateful(Dictable):
self.host_routes = [FakeV6HostRoute()]
self.dns_nameservers = ['2001:0200:feed:7ac0::1']
self.ipv6_ra_mode = None
self.ipv6_address_mode = n_const.DHCPV6_STATEFUL
self.ipv6_address_mode = constants.DHCPV6_STATEFUL
class FakeV6SubnetSlaac(object):
@ -476,7 +476,7 @@ class FakeV6SubnetSlaac(object):
self.gateway_ip = 'ffda:3ba5:a17a:4ba3::1'
self.enable_dhcp = True
self.host_routes = [FakeV6HostRoute()]
self.ipv6_address_mode = n_const.IPV6_SLAAC
self.ipv6_address_mode = constants.IPV6_SLAAC
self.ipv6_ra_mode = None
@ -489,7 +489,7 @@ class FakeV6SubnetStateless(object):
self.enable_dhcp = True
self.dns_nameservers = []
self.host_routes = []
self.ipv6_address_mode = n_const.DHCPV6_STATELESS
self.ipv6_address_mode = constants.DHCPV6_STATELESS
self.ipv6_ra_mode = None
@ -1064,7 +1064,7 @@ class TestDnsmasq(TestBase):
possible_leases = 0
for i, s in enumerate(network.subnets):
if (s.ip_version != 6
or s.ipv6_address_mode == n_const.DHCPV6_STATEFUL):
or s.ipv6_address_mode == constants.DHCPV6_STATEFUL):
if s.ip_version == 4:
expected.extend([prefix % (
i, s.cidr.split('/')[0], lease_duration, seconds)])

5
neutron/tests/unit/agent/linux/test_ip_lib.py
View File

@ -15,11 +15,12 @@
import mock
import netaddr
from neutron_lib import exceptions
import testtools
from neutron.agent.common import utils # noqa
from neutron.agent.linux import ip_lib
from neutron.common import exceptions
from neutron.common import exceptions as n_exc
from neutron.tests import base
NETNS_SAMPLE = [
@ -480,7 +481,7 @@ class TestIpWrapper(base.BaseTestCase):
def test_add_vxlan_invalid_port_length(self):
wrapper = ip_lib.IPWrapper()
self.assertRaises(exceptions.NetworkVxlanPortRangeError,
self.assertRaises(n_exc.NetworkVxlanPortRangeError,
wrapper.add_vxlan, 'vxlan0', 'vni0', group='group0',
dev='dev0', ttl='ttl0', tos='tos0',
local='local0', proxy=True,

16
neutron/tests/unit/agent/test_rpc.py
View File

@ -25,7 +25,8 @@ from neutron.tests import base
class AgentRPCPluginApi(base.BaseTestCase):
def _test_rpc_call(self, method):
agent = rpc.PluginApi('fake_topic')
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
expect_val = 'foo'
with mock.patch.object(agent.client, 'call') as mock_call,\
mock.patch.object(agent.client, 'prepare') as mock_prepare:
@ -46,7 +47,8 @@ class AgentRPCPluginApi(base.BaseTestCase):
def test_devices_details_list_unsupported(self):
agent = rpc.PluginApi('fake_topic')
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
expect_val_get_device_details = 'foo'
expect_val = [expect_val_get_device_details]
with mock.patch.object(agent.client, 'call') as mock_call, \
@ -75,7 +77,8 @@ class AgentPluginReportState(base.BaseTestCase):
mock.patch.object(reportStateAPI.client, 'prepare'
) as mock_prepare:
mock_prepare.return_value = reportStateAPI.client
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
reportStateAPI.report_state(ctxt, expected_agent_state,
use_call=True)
self.assertEqual(mock_call.call_args[0][0], ctxt)
@ -94,7 +97,8 @@ class AgentPluginReportState(base.BaseTestCase):
mock.patch.object(reportStateAPI.client, 'prepare'
) as mock_prepare:
mock_prepare.return_value = reportStateAPI.client
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
reportStateAPI.report_state(ctxt, expected_agent_state)
self.assertEqual(mock_cast.call_args[0][0], ctxt)
self.assertEqual(mock_cast.call_args[0][1], 'report_state')
@ -116,8 +120,8 @@ class AgentPluginReportState(base.BaseTestCase):
mock.patch.object(reportStateAPI.client, 'prepare'
) as mock_prepare:
mock_prepare.return_value = reportStateAPI.client
ctxt = oslo_context.RequestContext('fake_user',
'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
reportStateAPI.report_state(ctxt, expected_agent_state)
self.assertEqual(expected_time_str,
mock_cast.call_args[1]['time'])

11
neutron/tests/unit/agent/test_securitygroups_rpc.py
View File

@ -27,7 +27,6 @@ from neutron.agent import firewall as firewall_base
from neutron.agent.linux import iptables_manager
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.handlers import securitygroups_rpc
from neutron.common import constants as n_const
from neutron.common import ipv6_utils as ipv6
from neutron.common import rpc as n_rpc
from neutron import context
@ -682,7 +681,7 @@ class SGServerRpcCallBackTestCase(test_sg.SecurityGroupDBTestCase):
with self.network() as n,\
self.subnet(n, gateway_ip=fake_gateway,
cidr=fake_prefix, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC
ipv6_ra_mode=const.IPV6_SLAAC
) as subnet_v6,\
self.security_group() as sg1:
sg1_id = sg1['security_group']['id']
@ -750,7 +749,7 @@ class SGServerRpcCallBackTestCase(test_sg.SecurityGroupDBTestCase):
with self.network() as n,\
self.subnet(n, gateway_ip=fake_gateway,
cidr=fake_prefix, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC
ipv6_ra_mode=const.IPV6_SLAAC
) as subnet_v6,\
self.security_group() as sg1:
sg1_id = sg1['security_group']['id']
@ -825,7 +824,7 @@ class SGServerRpcCallBackTestCase(test_sg.SecurityGroupDBTestCase):
with self.network() as n,\
self.subnet(n, gateway_ip=fake_gateway,
cidr=fake_prefix, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC
ipv6_ra_mode=const.IPV6_SLAAC
) as subnet_v6,\
self.security_group() as sg1:
sg1_id = sg1['security_group']['id']
@ -893,7 +892,7 @@ class SGServerRpcCallBackTestCase(test_sg.SecurityGroupDBTestCase):
with self.network() as n,\
self.subnet(n, gateway_ip=fake_gateway,
cidr=fake_prefix, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC
ipv6_ra_mode=const.IPV6_SLAAC
) as subnet_v6,\
self.security_group() as sg1:
sg1_id = sg1['security_group']['id']
@ -941,7 +940,7 @@ class SGServerRpcCallBackTestCase(test_sg.SecurityGroupDBTestCase):
fake_prefix = FAKE_PREFIX[const.IPv6]
with self.network() as n,\
self.subnet(n, gateway_ip=None, cidr=fake_prefix,
ip_version=6, ipv6_ra_mode=n_const.IPV6_SLAAC
ip_version=6, ipv6_ra_mode=const.IPV6_SLAAC
) as subnet_v6,\
self.security_group() as sg1:
sg1_id = sg1['security_group']['id']

2
neutron/tests/unit/api/rpc/handlers/test_l3_rpc.py
View File

@ -13,10 +13,10 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from neutron_lib import constants
from oslo_config import cfg
from neutron.api.rpc.handlers import l3_rpc
from neutron.common import constants
from neutron import context
from neutron import manager
from neutron.tests.unit.db import test_db_base_plugin_v2

13
neutron/tests/unit/api/test_api_common.py
View File

@ -20,7 +20,6 @@ from webob import exc
from neutron.api import api_common as common
from neutron.api.v2 import base as base_v2
from neutron.common import exceptions as n_exc
from neutron.tests import base
@ -98,8 +97,9 @@ class APICommonTestCase(base.BaseTestCase):
params)
def test_convert_exception_to_http_exc_multiple_different_codes(self):
e = n_exc.MultipleExceptions([exceptions.NetworkInUse(net_id='nid'),
exceptions.PortNotFound(port_id='pid')])
e = exceptions.MultipleExceptions(
[exceptions.NetworkInUse(net_id='nid'),
exceptions.PortNotFound(port_id='pid')])
conv = common.convert_exception_to_http_exc(e, base_v2.FAULT_MAP, None)
self.assertIsInstance(conv, exc.HTTPConflict)
self.assertEqual(
@ -109,8 +109,9 @@ class APICommonTestCase(base.BaseTestCase):
jsonutils.loads(conv.body)['NeutronError']['message'])
def test_convert_exception_to_http_exc_multiple_same_codes(self):
e = n_exc.MultipleExceptions([exceptions.NetworkNotFound(net_id='nid'),
exceptions.PortNotFound(port_id='pid')])
e = exceptions.MultipleExceptions(
[exceptions.NetworkNotFound(net_id='nid'),
exceptions.PortNotFound(port_id='pid')])
conv = common.convert_exception_to_http_exc(e, base_v2.FAULT_MAP, None)
self.assertIsInstance(conv, exc.HTTPNotFound)
self.assertEqual(
@ -118,7 +119,7 @@ class APICommonTestCase(base.BaseTestCase):
jsonutils.loads(conv.body)['NeutronError']['message'])
def test_convert_exception_to_http_exc_multiple_empty_inner(self):
e = n_exc.MultipleExceptions([])
e = exceptions.MultipleExceptions([])
conv = common.convert_exception_to_http_exc(e, base_v2.FAULT_MAP, None)
self.assertIsInstance(conv, exc.HTTPInternalServerError)

2
neutron/tests/unit/common/test_ipv6_utils.py
View File

@ -15,8 +15,8 @@
import collections
import mock
from neutron_lib import constants
from neutron.common import constants
from neutron.common import ipv6_utils
from neutron.tests import base
from neutron.tests import tools

2
neutron/tests/unit/db/test_api.py
View File

@ -13,6 +13,7 @@
# limitations under the License.
import mock
from neutron_lib import exceptions
from oslo_config import cfg
from oslo_db import exception as db_exc
import osprofiler
@ -20,7 +21,6 @@ import sqlalchemy
from sqlalchemy.orm import exc
import testtools
from neutron.common import exceptions
from neutron.db import api as db_api
from neutron.tests import base

154
neutron/tests/unit/db/test_db_base_plugin_v2.py
View File

@ -1439,7 +1439,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.subnet(gateway_ip='fe80::1',
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
self.assertTrue(
ipv6_utils.is_auto_address_subnet(subnet['subnet']))
self.check_update_port_mac(subnet=subnet)
@ -1656,7 +1656,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.subnet(
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
ipv6_address_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC,
gateway_ip=constants.ATTR_NOT_SPECIFIED) as subnet:
with self.port(subnet=subnet) as port:
ips = port['port']['fixed_ips']
@ -1860,7 +1860,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
def test_create_port_invalid_fixed_ip_address_v6_pd_slaac(self):
with self.network(name='net') as network:
subnet = self._make_v6_subnet(
network, n_const.IPV6_SLAAC, ipv6_pd=True)
network, constants.IPV6_SLAAC, ipv6_pd=True)
net_id = subnet['subnet']['network_id']
subnet_id = subnet['subnet']['id']
# update subnet with new prefix
@ -1878,7 +1878,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
def test_update_port_invalid_fixed_ip_address_v6_pd_slaac(self):
with self.network(name='net') as network:
subnet = self._make_v6_subnet(
network, n_const.IPV6_SLAAC, ipv6_pd=True)
network, constants.IPV6_SLAAC, ipv6_pd=True)
net_id = subnet['subnet']['network_id']
subnet_id = subnet['subnet']['id']
# update subnet with new prefix
@ -1906,7 +1906,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
def test_update_port_invalid_subnet_v6_pd_slaac(self):
with self.network(name='net') as network:
subnet = self._make_v6_subnet(
network, n_const.IPV6_SLAAC, ipv6_pd=True)
network, constants.IPV6_SLAAC, ipv6_pd=True)
subnet_id = subnet['subnet']['id']
# update subnet with new prefix
prefix = '2001::/64'
@ -1934,7 +1934,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.subnet(gateway_ip='fe80::1',
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
'ip_address': '2607:f0d0:1002:51::5'}]}
net_id = subnet['subnet']['network_id']
@ -1946,7 +1946,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.subnet(gateway_ip='fe80::1',
cidr='fe80::/64',
ip_version=6,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
kwargs = {"fixed_ips": [{'subnet_id': subnet['subnet']['id'],
'ip_address': 'fe80::1'}]}
net_id = subnet['subnet']['network_id']
@ -1962,7 +1962,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.subnet(gateway_ip='fe80::1',
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
with self.port(subnet,
fixed_ips=[{'subnet_id':
subnet['subnet']['id']}]) as port:
@ -1981,7 +1981,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
gateway_ip='fe80::1',
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet2:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet2:
with self.port(
subnet,
fixed_ips=[{'subnet_id': subnet['subnet']['id']},
@ -2010,7 +2010,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
cidr='2607:f0d0:1002:51::/64',
ip_version=6,
gateway_ip='fe80::1',
ipv6_address_mode=n_const.IPV6_SLAAC):
ipv6_address_mode=constants.IPV6_SLAAC):
subnet_ip_net = netaddr.IPNetwork(subnet_v4['subnet']['cidr'])
# Create a router port without specifying fixed_ips
port = self._make_port(
@ -2031,7 +2031,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
res = self._create_network(fmt=self.fmt, name='net',
admin_state_up=True)
network = self.deserialize(self.fmt, res)
subnet = self._make_v6_subnet(network, n_const.IPV6_SLAAC)
subnet = self._make_v6_subnet(network, constants.IPV6_SLAAC)
port = self._make_port(self.fmt, network['network']['id'])
self.assertEqual(1, len(port['port']['fixed_ips']))
self.assertEqual(self._calc_ipv6_addr_by_EUI64(port, subnet),
@ -2048,7 +2048,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
with self.port(subnet=subnet, fixed_ips=fixed_ips) as port:
port_fixed_ips = port['port']['fixed_ips']
self.assertEqual(1, len(port_fixed_ips))
if addr_mode == n_const.IPV6_SLAAC:
if addr_mode == constants.IPV6_SLAAC:
exp_ip_addr = self._calc_ipv6_addr_by_EUI64(port, subnet)
self.assertEqual(exp_ip_addr,
port_fixed_ips[0]['ip_address'])
@ -2057,15 +2057,15 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
def test_create_port_with_ipv6_slaac_subnet_in_fixed_ips(self):
self._test_create_port_with_ipv6_subnet_in_fixed_ips(
addr_mode=n_const.IPV6_SLAAC)
addr_mode=constants.IPV6_SLAAC)
def test_create_port_with_ipv6_pd_subnet_in_fixed_ips(self):
self._test_create_port_with_ipv6_subnet_in_fixed_ips(
addr_mode=n_const.IPV6_SLAAC, ipv6_pd=True)
addr_mode=constants.IPV6_SLAAC, ipv6_pd=True)
def test_create_port_with_ipv6_dhcp_stateful_subnet_in_fixed_ips(self):
self._test_create_port_with_ipv6_subnet_in_fixed_ips(
addr_mode=n_const.DHCPV6_STATEFUL)
addr_mode=constants.DHCPV6_STATEFUL)
def test_create_port_with_multiple_ipv4_and_ipv6_subnets(self):
"""Test port create with multiple IPv4, IPv6 DHCP/SLAAC subnets."""
@ -2078,13 +2078,13 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
{'gateway': '10.0.1.1', 'cidr': '10.0.1.0/24',
'ip_version': 4, 'ra_addr_mode': None},
{'gateway': 'fe80::1', 'cidr': 'fe80::/64',
'ip_version': 6, 'ra_addr_mode': n_const.IPV6_SLAAC},
'ip_version': 6, 'ra_addr_mode': constants.IPV6_SLAAC},
{'gateway': 'fe81::1', 'cidr': 'fe81::/64',
'ip_version': 6, 'ra_addr_mode': n_const.IPV6_SLAAC},
'ip_version': 6, 'ra_addr_mode': constants.IPV6_SLAAC},
{'gateway': 'fe82::1', 'cidr': 'fe82::/64',
'ip_version': 6, 'ra_addr_mode': n_const.DHCPV6_STATEFUL},
'ip_version': 6, 'ra_addr_mode': constants.DHCPV6_STATEFUL},
{'gateway': 'fe83::1', 'cidr': 'fe83::/64',
'ip_version': 6, 'ra_addr_mode': n_const.DHCPV6_STATEFUL}]
'ip_version': 6, 'ra_addr_mode': constants.DHCPV6_STATEFUL}]
subnets = {}
for sub_dict in sub_dicts:
subnet = self._make_subnet(
@ -2102,15 +2102,15 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
# IPv4 subnets, one of the DHCPv6 subnets, and both of the IPv6
# SLAAC subnets.
self.assertEqual(4, len(port['port']['fixed_ips']))
addr_mode_count = {None: 0, n_const.DHCPV6_STATEFUL: 0,
n_const.IPV6_SLAAC: 0}
addr_mode_count = {None: 0, constants.DHCPV6_STATEFUL: 0,
constants.IPV6_SLAAC: 0}
for fixed_ip in port['port']['fixed_ips']:
subnet_id = fixed_ip['subnet_id']
if subnet_id in subnets:
addr_mode_count[subnets[subnet_id]['ra_addr_mode']] += 1
self.assertEqual(1, addr_mode_count[None])
self.assertEqual(1, addr_mode_count[n_const.DHCPV6_STATEFUL])
self.assertEqual(2, addr_mode_count[n_const.IPV6_SLAAC])
self.assertEqual(1, addr_mode_count[constants.DHCPV6_STATEFUL])
self.assertEqual(2, addr_mode_count[constants.IPV6_SLAAC])
def test_delete_port_with_ipv6_slaac_address(self):
"""Test that a port with an IPv6 SLAAC address can be deleted."""
@ -2118,7 +2118,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
admin_state_up=True)
network = self.deserialize(self.fmt, res)
# Create a port that has an associated IPv6 SLAAC address
self._make_v6_subnet(network, n_const.IPV6_SLAAC)
self._make_v6_subnet(network, constants.IPV6_SLAAC)
res = self._create_port(self.fmt, net_id=network['network']['id'])
port = self.deserialize(self.fmt, res)
self.assertEqual(1, len(port['port']['fixed_ips']))
@ -2135,7 +2135,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
# Create a port using an IPv4 subnet and an IPv6 SLAAC subnet
self._make_subnet(self.fmt, network, gateway='10.0.0.1',
cidr='10.0.0.0/24', ip_version=4)
subnet_v6 = self._make_v6_subnet(network, n_const.IPV6_SLAAC)
subnet_v6 = self._make_v6_subnet(network, constants.IPV6_SLAAC)
res = self._create_port(self.fmt, net_id=network['network']['id'])
port = self.deserialize(self.fmt, res)
self.assertEqual(2, len(port['port']['fixed_ips']))
@ -2159,7 +2159,7 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
# Create a port using an IPv4 subnet and an IPv6 SLAAC subnet
subnet_v4 = self._make_subnet(self.fmt, network, gateway='10.0.0.1',
cidr='10.0.0.0/24', ip_version=4)
subnet_v6 = self._make_v6_subnet(network, n_const.IPV6_SLAAC)
subnet_v6 = self._make_v6_subnet(network, constants.IPV6_SLAAC)
res = self._create_port(self.fmt, net_id=network['network']['id'])
port = self.deserialize(self.fmt, res)
self.assertEqual(2, len(port['port']['fixed_ips']))
@ -2186,12 +2186,12 @@ fixed_ips=ip_address%%3D%s&fixed_ips=ip_address%%3D%s&fixed_ips=subnet_id%%3D%s
gateway='2001:100::1',
cidr='2001:100::0/64',
ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC)
v6_subnet_2 = self._make_subnet(self.fmt, network,
gateway='2001:200::1',
cidr='2001:200::0/64',
ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC)
port = self._make_port(self.fmt, network['network']['id'])
port_mac = port['port']['mac_address']
cidr_1 = v6_subnet_1['subnet']['cidr']
@ -3367,8 +3367,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
network = self.deserialize(self.fmt, res)
subnet = self._make_subnet(self.fmt, network, gateway='fe80::1',
cidr='fe80::/64', ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC)
kwargs = {}
if port_owner:
kwargs['device_owner'] = port_owner
@ -3668,8 +3668,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
'allocation_pools': allocation_pools}
self._test_create_subnet(expected=expected, gateway_ip=gateway,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
# Gateway is first IP in IPv6 DHCPv6 stateful subnet
gateway = '2001::1'
allocation_pools = [{'start': '2001::2',
@ -3679,15 +3679,15 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
'allocation_pools': allocation_pools}
self._test_create_subnet(expected=expected, gateway_ip=gateway,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
# If gateway_ip is not specified, allocate first IP from the subnet
expected = {'gateway_ip': gateway,
'cidr': cidr}
self._test_create_subnet(expected=expected,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC)
@testtools.skipIf(tools.is_bsd(), 'bug/1484837')
def test_create_subnet_ipv6_pd_gw_values(self):
@ -3701,8 +3701,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
'allocation_pools': allocation_pools}
self._test_create_subnet(expected=expected, gateway_ip=gateway,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATELESS,
ipv6_address_mode=n_const.DHCPV6_STATELESS)
ipv6_ra_mode=constants.DHCPV6_STATELESS,
ipv6_address_mode=constants.DHCPV6_STATELESS)
# Gateway is first IP in IPv6 DHCPv6 Stateless subnet
gateway = '::1'
allocation_pools = [{'start': '::2',
@ -3712,15 +3712,15 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
'allocation_pools': allocation_pools}
self._test_create_subnet(expected=expected, gateway_ip=gateway,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATELESS,
ipv6_address_mode=n_const.DHCPV6_STATELESS)
ipv6_ra_mode=constants.DHCPV6_STATELESS,
ipv6_address_mode=constants.DHCPV6_STATELESS)
# If gateway_ip is not specified, allocate first IP from the subnet
expected = {'gateway_ip': gateway,
'cidr': cidr}
self._test_create_subnet(expected=expected,
cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC)
def test_create_subnet_gw_outside_cidr_returns_201(self):
with self.network() as network:
@ -4058,7 +4058,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_create_subnet_ipv6_ra_modes(self):
# Test all RA modes with no address mode specified
for ra_mode in n_const.IPV6_MODES:
for ra_mode in constants.IPV6_MODES:
self._test_validate_subnet_ipv6_modes(
ipv6_ra_mode=ra_mode)
self._test_validate_subnet_ipv6_pd_modes(
@ -4066,7 +4066,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_create_subnet_ipv6_addr_modes(self):
# Test all address modes with no RA mode specified
for addr_mode in n_const.IPV6_MODES:
for addr_mode in constants.IPV6_MODES:
self._test_validate_subnet_ipv6_modes(
ipv6_address_mode=addr_mode)
self._test_validate_subnet_ipv6_pd_modes(
@ -4074,7 +4074,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_create_subnet_ipv6_same_ra_and_addr_modes(self):
# Test all ipv6 modes with ra_mode==addr_mode
for ipv6_mode in n_const.IPV6_MODES:
for ipv6_mode in constants.IPV6_MODES:
self._test_validate_subnet_ipv6_modes(
ipv6_ra_mode=ipv6_mode,
ipv6_address_mode=ipv6_mode)
@ -4085,7 +4085,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_create_subnet_ipv6_different_ra_and_addr_modes(self):
# Test all ipv6 modes with ra_mode!=addr_mode
for ra_mode, addr_mode in itertools.permutations(
n_const.IPV6_MODES, 2):
constants.IPV6_MODES, 2):
self._test_validate_subnet_ipv6_modes(
expect_success=not (ra_mode and addr_mode),
ipv6_ra_mode=ra_mode,
@ -4101,8 +4101,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
subnet = self._test_create_subnet(
gateway_ip=gateway_ip, cidr=cidr,
ip_version=constants.IP_VERSION_6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self.assertEqual(constants.IP_VERSION_6,
subnet['subnet']['ip_version'])
self.assertEqual(gateway_ip,
@ -4119,8 +4119,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
self._test_create_subnet(
gateway_ip=gateway_ip, cidr=cidr,
ip_version=constants.IP_VERSION_6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self.assertEqual(webob.exc.HTTPClientError.code,
ctx_manager.exception.code)
@ -4130,8 +4130,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
subnet = self._test_create_subnet(
gateway_ip=gateway_ip, cidr=cidr,
ip_version=constants.IP_VERSION_6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL,
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self.assertEqual(constants.IP_VERSION_6,
subnet['subnet']['ip_version'])
self.assertEqual(gateway_ip,
@ -4145,15 +4145,15 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
self._test_create_subnet(
gateway_ip=gateway_ip, cidr=cidr, ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC)
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC)
def test_create_subnet_ipv6_attributes_no_dhcp_enabled(self):
gateway_ip = 'fe80::1'
cidr = 'fe80::/64'
with testlib_api.ExpectedException(
webob.exc.HTTPClientError) as ctx_manager:
for mode in n_const.IPV6_MODES:
for mode in constants.IPV6_MODES:
self._test_create_subnet(gateway_ip=gateway_ip,
cidr=cidr, ip_version=6,
enable_dhcp=False,
@ -4191,7 +4191,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
with testlib_api.ExpectedException(
webob.exc.HTTPClientError) as ctx_manager:
self._test_create_subnet(cidr=cidr, ip_version=4,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL)
ipv6_ra_mode=constants.DHCPV6_STATEFUL)
self.assertEqual(webob.exc.HTTPClientError.code,
ctx_manager.exception.code)
@ -4201,7 +4201,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
webob.exc.HTTPClientError) as ctx_manager:
self._test_create_subnet(
cidr=cidr, ip_version=4,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)
ipv6_address_mode=constants.DHCPV6_STATEFUL)
self.assertEqual(webob.exc.HTTPClientError.code,
ctx_manager.exception.code)
@ -4258,30 +4258,30 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_create_subnet_ipv6_slaac_with_port_on_network(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.IPV6_SLAAC)
constants.IPV6_SLAAC)
def test_create_subnet_dhcpv6_stateless_with_port_on_network(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.DHCPV6_STATELESS)
constants.DHCPV6_STATELESS)
def test_create_subnet_ipv6_slaac_with_dhcp_port_on_network(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.IPV6_SLAAC,
constants.IPV6_SLAAC,
device_owner=constants.DEVICE_OWNER_DHCP)
def test_create_subnet_ipv6_slaac_with_router_intf_on_network(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.IPV6_SLAAC,
constants.IPV6_SLAAC,
device_owner=constants.DEVICE_OWNER_ROUTER_INTF)
def test_create_subnet_ipv6_slaac_with_snat_intf_on_network(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.IPV6_SLAAC,
constants.IPV6_SLAAC,
device_owner=constants.DEVICE_OWNER_ROUTER_SNAT)
def test_create_subnet_ipv6_slaac_with_db_reference_error(self):
self._test_create_subnet_ipv6_auto_addr_with_port_on_network(
n_const.IPV6_SLAAC, insert_db_reference_error=True)
constants.IPV6_SLAAC, insert_db_reference_error=True)
def test_update_subnet_no_gateway(self):
with self.subnet() as subnet:
@ -4412,11 +4412,11 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_subnet_update_ipv4_and_ipv6_pd_slaac_subnets(self):
self._test_subnet_update_ipv4_and_ipv6_pd_subnets(
ra_addr_mode=n_const.IPV6_SLAAC)
ra_addr_mode=constants.IPV6_SLAAC)
def test_subnet_update_ipv4_and_ipv6_pd_v6stateless_subnets(self):
self._test_subnet_update_ipv4_and_ipv6_pd_subnets(
ra_addr_mode=n_const.DHCPV6_STATELESS)
ra_addr_mode=constants.DHCPV6_STATELESS)
def test_update_subnet_shared_returns_400(self):
with self.network(shared=True) as network:
@ -4543,10 +4543,10 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_update_subnet_ipv6_attributes_fails(self):
with self.subnet(ip_version=6, cidr='fe80::/64',
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_ra_mode': n_const.DHCPV6_STATEFUL,
'ipv6_address_mode': n_const.DHCPV6_STATEFUL}}
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_ra_mode': constants.DHCPV6_STATEFUL,
'ipv6_address_mode': constants.DHCPV6_STATEFUL}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
res = req.get_response(self.api)
@ -4555,8 +4555,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_update_subnet_ipv6_ra_mode_fails(self):
with self.subnet(ip_version=6, cidr='fe80::/64',
ipv6_ra_mode=n_const.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_ra_mode': n_const.DHCPV6_STATEFUL}}
ipv6_ra_mode=constants.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_ra_mode': constants.DHCPV6_STATEFUL}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
res = req.get_response(self.api)
@ -4565,8 +4565,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_update_subnet_ipv6_address_mode_fails(self):
with self.subnet(ip_version=6, cidr='fe80::/64',
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_address_mode': n_const.DHCPV6_STATEFUL}}
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
data = {'subnet': {'ipv6_address_mode': constants.DHCPV6_STATEFUL}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
res = req.get_response(self.api)
@ -4575,8 +4575,8 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
def test_update_subnet_ipv6_cannot_disable_dhcp(self):
with self.subnet(ip_version=6, cidr='fe80::/64',
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC) as subnet:
data = {'subnet': {'enable_dhcp': False}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
@ -4588,7 +4588,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
with self.network() as network:
with self.subnet(network=network) as subnet:
data = {'subnet': {'ipv6_ra_mode':
n_const.DHCPV6_STATEFUL}}
constants.DHCPV6_STATEFUL}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
res = req.get_response(self.api)
@ -4599,7 +4599,7 @@ class TestSubnetsV2(NeutronDbPluginV2TestCase):
with self.network() as network:
with self.subnet(network=network) as subnet:
data = {'subnet': {'ipv6_address_mode':
n_const.DHCPV6_STATEFUL}}
constants.DHCPV6_STATEFUL}}
req = self.new_update_request('subnets', data,
subnet['subnet']['id'])
res = req.get_response(self.api)

13
neutron/tests/unit/db/test_ipam_backend_mixin.py
View File

@ -18,7 +18,6 @@ import netaddr
from neutron_lib import constants
import webob.exc
from neutron.common import constants as n_const
from neutron.db import db_base_plugin_v2
from neutron.db import ipam_backend_mixin
from neutron.db import portbindings_db
@ -51,8 +50,8 @@ class TestIpamBackendMixin(base.BaseTestCase):
return results
def _mock_slaac_subnet_on(self):
slaac_subnet = {'ipv6_address_mode': n_const.IPV6_SLAAC,
'ipv6_ra_mode': n_const.IPV6_SLAAC}
slaac_subnet = {'ipv6_address_mode': constants.IPV6_SLAAC,
'ipv6_ra_mode': constants.IPV6_SLAAC}
self.mixin._get_subnet = mock.Mock(return_value=slaac_subnet)
def _mock_slaac_subnet_off(self):
@ -64,8 +63,8 @@ class TestIpamBackendMixin(base.BaseTestCase):
"""Mock incoming subnets as autoaddressed."""
def _get_subnet(context, subnet_id):
if subnet_id in subnet_ids:
return {'ipv6_address_mode': n_const.IPV6_SLAAC,
'ipv6_ra_mode': n_const.IPV6_SLAAC}
return {'ipv6_address_mode': constants.IPV6_SLAAC,
'ipv6_ra_mode': constants.IPV6_SLAAC}
else:
return {'ipv6_address_mode': None,
'ipv6_ra_mode': None}
@ -135,8 +134,8 @@ class TestIpamBackendMixin(base.BaseTestCase):
# mock to test auto address part
pd_subnet = {'subnetpool_id': constants.IPV6_PD_POOL_ID,
'ipv6_address_mode': n_const.IPV6_SLAAC,
'ipv6_ra_mode': n_const.IPV6_SLAAC}
'ipv6_address_mode': constants.IPV6_SLAAC,
'ipv6_ra_mode': constants.IPV6_SLAAC}
self.mixin._get_subnet = mock.Mock(return_value=pd_subnet)
# make a copy of original_ips

4
neutron/tests/unit/db/test_ipam_pluggable_backend.py
View File

@ -359,8 +359,8 @@ class TestDbBasePluginIpam(test_db_base.NeutronDbPluginV2TestCase):
allocation_pools = [netaddr.IPRange('::2', '::ffff:ffff:ffff:ffff')]
with self.subnet(cidr=None, ip_version=6,
subnetpool_id=constants.IPV6_PD_POOL_ID,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC):
ipv6_ra_mode=constants.IPV6_SLAAC,
ipv6_address_mode=constants.IPV6_SLAAC):
pool_mock.get_instance.assert_called_once_with(None, mock.ANY)
self.assertTrue(mocks['driver'].allocate_subnet.called)
request = mocks['driver'].allocate_subnet.call_args[0][0]

8
neutron/tests/unit/db/test_l3_hamode_db.py
View File

@ -65,7 +65,7 @@ class L3HATestFramework(testlib_api.SqlTestCase):
self.plugin.router_scheduler = l3_agent_scheduler.ChanceScheduler()
self.agent1 = helpers.register_l3_agent()
self.agent2 = helpers.register_l3_agent(
'host_2', n_const.L3_AGENT_MODE_DVR_SNAT)
'host_2', constants.L3_AGENT_MODE_DVR_SNAT)
def _create_router(self, ha=True, tenant_id='tenant1', distributed=None,
ctx=None, admin_state_up=True):
@ -839,7 +839,7 @@ class L3HATestCase(L3HATestFramework):
# Test setup registers two l3 agents.
# Register another l3 agent with dvr mode and assert that
# get_number_of_ha_agent_candidates return 2.
helpers.register_l3_agent('host_3', n_const.L3_AGENT_MODE_DVR)
helpers.register_l3_agent('host_3', constants.L3_AGENT_MODE_DVR)
num_ha_candidates = self.plugin.get_number_of_agents_for_scheduling(
self.admin_ctx)
self.assertEqual(2, num_ha_candidates)
@ -852,7 +852,7 @@ class L3HATestCase(L3HATestFramework):
# Test setup registers two l3 agents.
# Register another l3 agent with dvr mode and assert that
# get_number_of_ha_agent_candidates return 2.
helpers.register_l3_agent('host_3', n_const.L3_AGENT_MODE_DVR_SNAT)
helpers.register_l3_agent('host_3', constants.L3_AGENT_MODE_DVR_SNAT)
num_ha_candidates = self.plugin.get_number_of_agents_for_scheduling(
self.admin_ctx)
self.assertEqual(3, num_ha_candidates)
@ -1054,7 +1054,7 @@ class L3HAModeDbTestCase(L3HATestFramework):
def test_ensure_host_set_on_ports_dvr_ha_binds_to_active(self):
agent3 = helpers.register_l3_agent('host_3',
n_const.L3_AGENT_MODE_DVR_SNAT)
constants.L3_AGENT_MODE_DVR_SNAT)
ext_net = self._create_network(self.core_plugin, self.admin_ctx,
external=True)
int_net = self._create_network(self.core_plugin, self.admin_ctx)

5
neutron/tests/unit/extensions/test_dns.py
View File

@ -15,10 +15,9 @@
import math
import netaddr
from neutron_lib import constants as n_const
from neutron_lib import constants
from oslo_config import cfg
from neutron.common import constants
from neutron.common import utils
from neutron import context
from neutron.db import db_base_plugin_v2
@ -92,7 +91,7 @@ class DnsExtensionTestCase(test_plugin.Ml2PluginV2TestCase):
data['port'][arg] = kwargs[arg]
# create a dhcp port device id if one hasn't been supplied
if ('device_owner' in kwargs and
kwargs['device_owner'] == n_const.DEVICE_OWNER_DHCP and
kwargs['device_owner'] == constants.DEVICE_OWNER_DHCP and
'host' in kwargs and
'device_id' not in kwargs):
device_id = utils.get_dhcp_agent_device_id(net_id, kwargs['host'])

76
neutron/tests/unit/extensions/test_l3.py
View File

@ -19,7 +19,7 @@ import copy
import mock
import netaddr
from neutron_lib import constants as l3_constants
from neutron_lib import constants as lib_constants
from neutron_lib import exceptions as n_exc
from oslo_config import cfg
from oslo_utils import importutils
@ -34,7 +34,6 @@ from neutron.callbacks import events
from neutron.callbacks import exceptions
from neutron.callbacks import registry
from neutron.callbacks import resources
from neutron.common import constants as n_const
from neutron import context
from neutron.db import common_db_mixin
from neutron.db import db_base_plugin_v2
@ -66,7 +65,7 @@ _uuid = uuidutils.generate_uuid
_get_path = test_base._get_path
DEVICE_OWNER_COMPUTE = l3_constants.DEVICE_OWNER_COMPUTE_PREFIX + 'fake'
DEVICE_OWNER_COMPUTE = lib_constants.DEVICE_OWNER_COMPUTE_PREFIX + 'fake'
class L3TestExtensionManager(object):
@ -322,7 +321,7 @@ class TestL3NatAgentSchedulingServicePlugin(TestL3NatServicePlugin,
self.router_scheduler = importutils.import_object(
cfg.CONF.router_scheduler_driver)
self.agent_notifiers.update(
{l3_constants.AGENT_TYPE_L3: l3_rpc_agent_api.L3AgentNotifyAPI()})
{lib_constants.AGENT_TYPE_L3: l3_rpc_agent_api.L3AgentNotifyAPI()})
class L3NatTestCaseMixin(object):
@ -932,8 +931,8 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
self._create_subnet(self.fmt,
net_id=n['network']['id'],
ip_version=6, cidr='2001:db8:1::/64',
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC))
ipv6_ra_mode=lib_constants.IPV6_SLAAC,
ipv6_address_mode=lib_constants.IPV6_SLAAC))
res3 = self._show('routers', r['router']['id'])
fips = (res3['router']['external_gateway_info']
['external_fixed_ips'])
@ -1015,9 +1014,9 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
Verify the valid use-cases of an IPv6 subnet where we
are allowed to associate to the Neutron Router are successful.
"""
slaac = n_const.IPV6_SLAAC
stateful = n_const.DHCPV6_STATEFUL
stateless = n_const.DHCPV6_STATELESS
slaac = lib_constants.IPV6_SLAAC
stateful = lib_constants.DHCPV6_STATEFUL
stateless = lib_constants.DHCPV6_STATELESS
use_cases = [{'msg': 'IPv6 Subnet Modes (slaac, none)',
'ra_mode': slaac, 'address_mode': None},
{'msg': 'IPv6 Subnet Modes (none, none)',
@ -1136,13 +1135,13 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
"""
use_cases = [{'msg': 'IPv6 Subnet Modes (none, slaac)',
'ra_mode': None,
'address_mode': n_const.IPV6_SLAAC},
'address_mode': lib_constants.IPV6_SLAAC},
{'msg': 'IPv6 Subnet Modes (none, dhcpv6-stateful)',
'ra_mode': None,
'address_mode': n_const.DHCPV6_STATEFUL},
'address_mode': lib_constants.DHCPV6_STATEFUL},
{'msg': 'IPv6 Subnet Modes (none, dhcpv6-stateless)',
'ra_mode': None,
'address_mode': n_const.DHCPV6_STATELESS}]
'address_mode': lib_constants.DHCPV6_STATELESS}]
for uc in use_cases:
with self.router() as r, self.network() as n:
with self.subnet(network=n, cidr='fd00::1/64',
@ -1227,7 +1226,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
self.assertIn('port_id', body)
self.assertEqual(p['port']['id'], body['port_id'])
expected_port_update = {
'device_owner': l3_constants.DEVICE_OWNER_ROUTER_INTF,
'device_owner': lib_constants.DEVICE_OWNER_ROUTER_INTF,
'device_id': r['router']['id']}
update_port.assert_any_call(
mock.ANY, p['port']['id'], {'port': expected_port_update})
@ -1292,7 +1291,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
port_id, device_id):
self.assertNotIn('port_id', body)
expected_port_update_before_update = {
'device_owner': l3_constants.DEVICE_OWNER_ROUTER_INTF,
'device_owner': lib_constants.DEVICE_OWNER_ROUTER_INTF,
'device_id': device_id}
expected_port_update_after_fail = {
'device_owner': '',
@ -1431,7 +1430,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
with self.network() as network, self.router() as r:
# Create a router port without ips
p = self._make_port(self.fmt, network['network']['id'],
device_owner=l3_constants.DEVICE_OWNER_ROUTER_INTF)
device_owner=lib_constants.DEVICE_OWNER_ROUTER_INTF)
err_code = exc.HTTPBadRequest.code
self._router_interface_action('add',
r['router']['id'],
@ -1567,18 +1566,18 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
self.subnet(
cidr='2001:db8::/64', network=n,
ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC,
ipv6_address_mode=n_const.IPV6_SLAAC)) as s3, (
ipv6_ra_mode=lib_constants.IPV6_SLAAC,
ipv6_address_mode=lib_constants.IPV6_SLAAC)) as s3, (
self.subnet(
cidr='2001:db8:1::/64', network=n,
ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATEFUL,
ipv6_address_mode=n_const.DHCPV6_STATEFUL)) as s4, (
ipv6_ra_mode=lib_constants.DHCPV6_STATEFUL,
ipv6_address_mode=lib_constants.DHCPV6_STATEFUL)) as s4, (
self.subnet(
cidr='2001:db8:2::/64', network=n,
ip_version=6,
ipv6_ra_mode=n_const.DHCPV6_STATELESS,
ipv6_address_mode=n_const.DHCPV6_STATELESS)) as s5:
ipv6_ra_mode=lib_constants.DHCPV6_STATELESS,
ipv6_address_mode=lib_constants.DHCPV6_STATELESS)) as s5:
self._set_net_external(n['network']['id'])
self._add_external_gateway_to_router(
r['router']['id'],
@ -1646,7 +1645,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
with self.network(tenant_id='tenant_a',
set_context=True) as n:
with self.subnet(network=n):
for device_owner in l3_constants.ROUTER_INTERFACE_OWNERS:
for device_owner in lib_constants.ROUTER_INTERFACE_OWNERS:
self._create_port(
self.fmt, n['network']['id'],
tenant_id='tenant_a',
@ -1664,7 +1663,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
with self.network(tenant_id='tenant_a',
set_context=True) as n:
with self.subnet(network=n):
for device_owner in l3_constants.ROUTER_INTERFACE_OWNERS:
for device_owner in lib_constants.ROUTER_INTERFACE_OWNERS:
port_res = self._create_port(
self.fmt, n['network']['id'],
tenant_id='tenant_a',
@ -2024,7 +2023,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
self.assertEqual(400, res.status_int)
for p in self._list('ports')['ports']:
if (p['device_owner'] ==
l3_constants.DEVICE_OWNER_FLOATINGIP):
lib_constants.DEVICE_OWNER_FLOATINGIP):
self.fail('garbage port is not deleted')
def test_floatingip_with_assoc_fails(self):
@ -2032,7 +2031,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
'neutron.db.l3_db.L3_NAT_dbonly_mixin._check_and_get_fip_assoc')
def test_create_floatingip_with_assoc(
self, expected_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
self, expected_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
with self.floatingip_with_assoc() as fip:
body = self._show('floatingips', fip['floatingip']['id'])
self.assertEqual(body['floatingip']['id'],
@ -2076,11 +2075,11 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
with self.floatingip_with_assoc():
port_body = self._list('ports',
query_params='device_owner=network:floatingip')['ports'][0]
self.assertEqual(l3_constants.PORT_STATUS_NOTAPPLICABLE,
self.assertEqual(lib_constants.PORT_STATUS_NOTAPPLICABLE,
port_body['status'])
def test_floatingip_update(
self, expected_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
self, expected_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
with self.port() as p:
private_sub = {'subnet': {'id':
p['port']['fixed_ips'][0]['subnet_id']}}
@ -2191,7 +2190,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
expected_code=exc.HTTPBadRequest.code)
def test_floatingip_update_to_same_port_id_twice(
self, expected_status=l3_constants.FLOATINGIP_STATUS_ACTIVE):
self, expected_status=lib_constants.FLOATINGIP_STATUS_ACTIVE):
with self.port() as p:
private_sub = {'subnet': {'id':
p['port']['fixed_ips'][0]['subnet_id']}}
@ -2388,7 +2387,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
found = False
with self.floatingip_with_assoc():
for p in self._list('ports')['ports']:
if p['device_owner'] == l3_constants.DEVICE_OWNER_FLOATINGIP:
if p['device_owner'] == lib_constants.DEVICE_OWNER_FLOATINGIP:
self._delete('ports', p['id'],
expected_code=exc.HTTPConflict.code)
found = True
@ -2699,7 +2698,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
).filter(
models_v2.Port.network_id == internal_port['network_id'],
l3_db.RouterPort.port_type.in_(
l3_constants.ROUTER_INTERFACE_OWNERS
lib_constants.ROUTER_INTERFACE_OWNERS
),
models_v2.IPAllocation.subnet_id == internal_subnet['id']
).join(
@ -2738,7 +2737,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
found = False
with self.floatingip_with_assoc():
for p in self._list('ports')['ports']:
if p['device_owner'] == l3_constants.DEVICE_OWNER_ROUTER_INTF:
if p['device_owner'] == lib_constants.DEVICE_OWNER_ROUTER_INTF:
subnet_id = p['fixed_ips'][0]['subnet_id']
router_id = p['device_id']
self._router_interface_action(
@ -2752,7 +2751,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
found = False
with self.floatingip_with_assoc():
for p in self._list('ports')['ports']:
if p['device_owner'] == l3_constants.DEVICE_OWNER_ROUTER_INTF:
if p['device_owner'] == lib_constants.DEVICE_OWNER_ROUTER_INTF:
router_id = p['device_id']
self._router_interface_action(
'remove', router_id, None, p['id'],
@ -2784,12 +2783,12 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
def test_router_delete_ipv6_slaac_subnet_inuse_returns_409(self):
with self.router() as r:
with self._ipv6_subnet(n_const.IPV6_SLAAC) as s:
with self._ipv6_subnet(lib_constants.IPV6_SLAAC) as s:
self._test_router_delete_subnet_inuse_returns_409(r, s)
def test_router_delete_dhcpv6_stateless_subnet_inuse_returns_409(self):
with self.router() as r:
with self._ipv6_subnet(n_const.DHCPV6_STATELESS) as s:
with self._ipv6_subnet(lib_constants.DHCPV6_STATELESS) as s:
self._test_router_delete_subnet_inuse_returns_409(r, s)
def test_delete_ext_net_with_disassociated_floating_ips(self):
@ -3067,7 +3066,7 @@ class L3NatTestCaseBase(L3NatTestCaseMixin):
allocation_pools=allocation_pools,
cidr='120.0.0.0/24') as subnet:
kwargs = {
'device_owner': l3_constants.DEVICE_OWNER_ROUTER_GW,
'device_owner': lib_constants.DEVICE_OWNER_ROUTER_GW,
'device_id': 'fake_device'}
with self.port(subnet=subnet, **kwargs):
data = {'subnet': {'gateway_ip': '120.0.0.2'}}
@ -3127,7 +3126,7 @@ class L3AgentDbTestCaseBase(L3NatTestCaseMixin):
routers = self.plugin.get_sync_data(
context.get_admin_context(), None)
self.assertEqual(1, len(routers))
interfaces = routers[0][l3_constants.INTERFACE_KEY]
interfaces = routers[0][lib_constants.INTERFACE_KEY]
self.assertEqual(1, len(interfaces))
subnets = interfaces[0]['subnets']
self.assertEqual(1, len(subnets))
@ -3189,7 +3188,8 @@ class L3AgentDbTestCaseBase(L3NatTestCaseMixin):
self.core_plugin.update_port(ctx, p['port']['id'], port)
routers = self.plugin.get_sync_data(ctx, None)
self.assertEqual(1, len(routers))
interfaces = routers[0].get(l3_constants.INTERFACE_KEY, [])
interfaces = routers[0].get(lib_constants.INTERFACE_KEY,
[])
self.assertEqual(1, len(interfaces))
def test_l3_agent_routers_query_gateway(self):
@ -3215,7 +3215,7 @@ class L3AgentDbTestCaseBase(L3NatTestCaseMixin):
routers = self.plugin.get_sync_data(
context.get_admin_context(), [fip['floatingip']['router_id']])
self.assertEqual(1, len(routers))
floatingips = routers[0][l3_constants.FLOATINGIP_KEY]
floatingips = routers[0][lib_constants.FLOATINGIP_KEY]
self.assertEqual(1, len(floatingips))
self.assertEqual(floatingips[0]['id'],
fip['floatingip']['id'])

3
neutron/tests/unit/extensions/test_network_ip_availability.py
View File

@ -13,9 +13,10 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from neutron_lib import constants
import neutron.api.extensions as api_ext
import neutron.common.config as config
import neutron.common.constants as constants
import neutron.extensions
import neutron.services.network_ip_availability.plugin as plugin_module
import neutron.tests.unit.db.test_db_base_plugin_v2 as test_db_base_plugin_v2

4
neutron/tests/unit/hacking/test_checks.py
View File

@ -249,10 +249,10 @@ class HackingTestCase(base.BaseTestCase):
1, len(list(checks.check_assertempty(fail_code % (ec, ec),
"neutron/tests/test_assert.py"))))
self.assertEqual(
0, len(list(checks.check_assertfalse(pass_code1 % (ec, ec),
0, len(list(checks.check_asserttruefalse(pass_code1 % (ec, ec),
"neutron/tests/test_assert.py"))))
self.assertEqual(
0, len(list(checks.check_assertfalse(pass_code2 % ec,
0, len(list(checks.check_asserttruefalse(pass_code2 % ec,
"neutron/tests/test_assert.py"))))
def test_assertisinstance(self):

3
neutron/tests/unit/notifiers/test_nova.py
View File

@ -22,13 +22,12 @@ from oslo_config import cfg
from oslo_utils import uuidutils
from sqlalchemy.orm import attributes as sql_attr
from neutron.common import constants
from neutron.db import models_v2
from neutron.notifiers import nova
from neutron.tests import base
DEVICE_OWNER_COMPUTE = n_const.DEVICE_OWNER_COMPUTE_PREFIX + 'fake'
DEVICE_OWNER_BAREMETAL = constants.DEVICE_OWNER_BAREMETAL_PREFIX + 'fake'
DEVICE_OWNER_BAREMETAL = n_const.DEVICE_OWNER_BAREMETAL_PREFIX + 'fake'
class TestNovaNotify(base.BaseTestCase):

2
neutron/tests/unit/objects/test_common_types.py
View File

@ -57,7 +57,7 @@ class IPV6ModeEnumFieldTest(test_base.BaseTestCase, TestField):
super(IPV6ModeEnumFieldTest, self).setUp()
self.field = common_types.IPV6ModeEnumField()
self.coerce_good_values = [(mode, mode)
for mode in constants.IPV6_MODES]
for mode in const.IPV6_MODES]
self.coerce_bad_values = ['6', 4, 'type', 'slaacc']
self.to_primitive_values = self.coerce_good_values
self.from_primitive_values = self.coerce_good_values

3
neutron/tests/unit/plugins/ml2/drivers/l2pop/test_mech_driver.py
View File

@ -19,7 +19,6 @@ from neutron_lib import exceptions
from oslo_serialization import jsonutils
import testtools
from neutron.common import constants as n_const
from neutron.common import topics
from neutron import context
from neutron.extensions import portbindings
@ -435,7 +434,7 @@ class TestL2PopulationRpcTestCase(test_plugin.Ml2PluginV2TestCase):
cidr='2001:db8::/64',
ip_version=6,
gateway_ip='fe80::1',
ipv6_address_mode=n_const.IPV6_SLAAC) as subnet2:
ipv6_address_mode=constants.IPV6_SLAAC) as subnet2:
with self.port(
subnet,
fixed_ips=[{'subnet_id': subnet['subnet']['id']},

3
neutron/tests/unit/plugins/ml2/test_plugin.py
View File

@ -32,7 +32,6 @@ from neutron._i18n import _
from neutron.callbacks import events
from neutron.callbacks import registry
from neutron.callbacks import resources
from neutron.common import constants as n_const
from neutron.common import utils
from neutron import context
from neutron.db import agents_db
@ -2323,7 +2322,7 @@ class TestML2PluggableIPAM(test_ipam.UseIpamMixin, TestMl2SubnetsV2):
with self.subnet(network=network,
cidr='2001:100::0/64',
ip_version=6,
ipv6_ra_mode=n_const.IPV6_SLAAC) as subnet:
ipv6_ra_mode=constants.IPV6_SLAAC) as subnet:
with self.port(subnet=subnet) as port:
with mock.patch(driver) as driver_mock:
# Validate that deletion of SLAAC allocation happens

9
neutron/tests/unit/plugins/ml2/test_rpc.py
View File

@ -312,7 +312,8 @@ class RpcCallbacksTestCase(base.BaseTestCase):
class RpcApiTestCase(base.BaseTestCase):
def _test_rpc_api(self, rpcapi, topic, method, rpc_method, **kwargs):
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
expected_retval = 'foo' if rpc_method == 'call' else None
expected_version = kwargs.pop('version', None)
fanout = kwargs.pop('fanout', False)
@ -443,7 +444,8 @@ class RpcApiTestCase(base.BaseTestCase):
def test_update_device_list_unsupported(self):
rpcapi = agent_rpc.PluginApi(topics.PLUGIN)
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
devices_up = ['fake_device1', 'fake_device2']
devices_down = ['fake_device3', 'fake_device4']
expected_ret_val = {'devices_up': ['fake_device2'],
@ -485,7 +487,8 @@ class RpcApiTestCase(base.BaseTestCase):
def test_get_devices_details_list_and_failed_devices_unsupported(self):
rpcapi = agent_rpc.PluginApi(topics.PLUGIN)
ctxt = oslo_context.RequestContext('fake_user', 'fake_project')
ctxt = oslo_context.RequestContext(user='fake_user',
tenant='fake_project')
devices = ['fake_device1', 'fake_device2']
dev2_details = {'device': 'fake_device2', 'network_id': 'net_id',
'port_id': 'port_id', 'admin_state_up': True}

15
neutron/tests/unit/test_policy.py
View File

@ -16,7 +16,7 @@
"""Test of Policy Engine For Neutron"""
import mock
from neutron_lib import constants as const
from neutron_lib import constants
from neutron_lib import exceptions
from oslo_db import exception as db_exc
from oslo_policy import fixture as op_fixture
@ -27,7 +27,6 @@ from oslo_utils import importutils
import neutron
from neutron.api.v2 import attributes
from neutron.common import constants as n_const
from neutron.common import exceptions as n_exc
from neutron import context
from neutron import manager
from neutron import policy
@ -330,10 +329,10 @@ class NeutronPolicyTestCase(base.BaseTestCase):
oslo_policy.PolicyNotAuthorized)
def test_create_port_device_owner_regex(self):
blocked_values = (const.DEVICE_OWNER_NETWORK_PREFIX,
blocked_values = (constants.DEVICE_OWNER_NETWORK_PREFIX,
'network:abdef',
const.DEVICE_OWNER_DHCP,
const.DEVICE_OWNER_ROUTER_INTF)
constants.DEVICE_OWNER_DHCP,
constants.DEVICE_OWNER_ROUTER_INTF)
for val in blocked_values:
self._test_advsvc_action_on_attr(
'create', 'port', 'device_owner', val,
@ -570,7 +569,7 @@ class NeutronPolicyTestCase(base.BaseTestCase):
def test_tenant_id_check_no_target_field_raises(self):
# Try and add a bad rule
self.assertRaises(
n_exc.PolicyInitError,
exceptions.PolicyInitError,
oslo_policy.Rules.from_dict,
{'test_policy': 'tenant_id:(wrong_stuff)'})
@ -580,7 +579,7 @@ class NeutronPolicyTestCase(base.BaseTestCase):
action = "create_network"
target = {'tenant_id': 'fake'}
self.fakepolicyinit()
self.assertRaises(n_exc.PolicyCheckError,
self.assertRaises(exceptions.PolicyCheckError,
policy.enforce,
self.context, action, target)
@ -653,7 +652,7 @@ class NeutronPolicyTestCase(base.BaseTestCase):
attr, resource, target, action)
self.assertFalse(result)
target = {attr: const.ATTR_NOT_SPECIFIED, 'tgt-tenant': 'tenantA'}
target = {attr: constants.ATTR_NOT_SPECIFIED, 'tgt-tenant': 'tenantA'}
result = policy._is_attribute_explicitly_set(
attr, resource, target, action)
self.assertFalse(result)