from neutron.api.v2 import attributes
from neutron.common import constants
from neutron.common import exceptions as n_exc
+from neutron.common import rpc as n_rpc
from neutron.common import utils
from neutron.extensions import portbindings
from neutron import manager
LOG = logging.getLogger(__name__)
-class DhcpRpcCallbackMixin(object):
- """A mix-in that enable DHCP agent support in plugin implementations."""
+class DhcpRpcCallback(n_rpc.RpcCallback):
+ """DHCP agent RPC callback in plugin implementations."""
+
+ # API version history:
+ # 1.0 - Initial version.
+ # 1.1 - Added get_active_networks_info, create_dhcp_port,
+ # and update_dhcp_port methods.
+ RPC_API_VERSION = '1.1'
def _get_active_networks(self, context, **kwargs):
"""Retrieve and return a list of the active networks."""
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api import extensions as neutron_extensions
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.common import constants as const
from neutron.common import exceptions
from neutron.common import rpc as n_rpc
from neutron.db import allowedaddresspairs_db as addr_pair_db
from neutron.db import api as db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extradhcpopt_db
from neutron.db import l3_db
class RestProxyCallbacks(n_rpc.RpcCallback,
- sg_rpc_base.SecurityGroupServerRpcCallbackMixin,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
+ sg_rpc_base.SecurityGroupServerRpcCallbackMixin):
RPC_API_VERSION = '1.1'
self._dhcp_agent_notifier
)
self.endpoints = [RestProxyCallbacks(),
+ dhcp_rpc.DhcpRpcCallback(),
agents_db.AgentExtRpcCallback()]
self.conn.create_consumer(self.topic, self.endpoints,
fanout=False)
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.common import constants as q_const
from neutron.common import rpc as n_rpc
from neutron.db import agentschedulers_db
from neutron.db import api as db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extraroute_db
from neutron.db import l3_agentschedulers_db
class BridgeRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
"""Agent callback."""
is_admin=False)
self.conn = n_rpc.create_connection(new=True)
self.endpoints = [BridgeRpcCallbacks(),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import constants
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extraroute_db
from neutron.db import l3_agentschedulers_db
LOG = logging.getLogger(__name__)
-class N1kvRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
-
- """Class to handle agent RPC calls."""
-
- # Set RPC API version to 1.1 by default.
- RPC_API_VERSION = '1.1'
-
-
class N1kvNeutronPluginV2(db_base_plugin_v2.NeutronDbPluginV2,
external_net_db.External_net_db_mixin,
extraroute_db.ExtraRoute_db_mixin,
self.service_topics = {svc_constants.CORE: topics.PLUGIN,
svc_constants.L3_ROUTER_NAT: topics.L3PLUGIN}
self.conn = n_rpc.create_connection(new=True)
- self.endpoints = [N1kvRpcCallbacks(),
+ self.endpoints = [dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from oslo.config import cfg
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import exceptions as n_exc
self.notifier = agent_notifier_api.AgentNotifierApi(
topics.AGENT)
self.endpoints = [rpc_callbacks.HyperVRpcCallbacks(self.notifier),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from neutron.common import constants as q_const
from neutron.common import rpc as n_rpc
-from neutron.db import dhcp_rpc_base
from neutron.openstack.common import log as logging
from neutron.plugins.hyperv import db as hyperv_db
LOG = logging.getLogger(__name__)
-class HyperVRpcCallbacks(
- n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
+class HyperVRpcCallbacks(n_rpc.RpcCallback):
# history
# 1.1 Support Security Group RPC
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import constants as q_const
from neutron.db import agentschedulers_db
from neutron.db import api as db_api
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extraroute_db
from neutron.db import l3_agentschedulers_db
class LinuxBridgeRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin
):
svc_constants.L3_ROUTER_NAT: topics.L3PLUGIN}
self.conn = n_rpc.create_connection(new=True)
self.endpoints = [LinuxBridgeRpcCallbacks(),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from sqlalchemy.orm import exc as sa_exc
from webob import exc as w_exc
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.v2 import attributes
from neutron.common import constants
from neutron.common import exceptions as n_exc
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import l3_db
from neutron.db import models_v2
raise MidonetPluginException(msg=exc)
-class MidoRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
- RPC_API_VERSION = '1.1'
-
-
class MidonetPluginException(n_exc.NeutronException):
message = _("%(msg)s")
# RPC support
self.topic = topics.PLUGIN
self.conn = n_rpc.create_connection(new=True)
- self.endpoints = [MidoRpcCallbacks(),
+ self.endpoints = [dhcp_rpc.DhcpRpcCallback(),
agents_db.AgentExtRpcCallback()]
self.conn.create_consumer(self.topic, self.endpoints,
fanout=False)
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.v2 import attributes
from neutron.common import constants as const
from neutron.common import exceptions as exc
def start_rpc_listeners(self):
self.endpoints = [rpc.RpcCallbacks(self.notifier, self.type_manager),
+ dhcp_rpc.DhcpRpcCallback(),
agents_db.AgentExtRpcCallback()]
self.topic = topics.PLUGIN
self.conn = n_rpc.create_connection(new=True)
from neutron.common import rpc as n_rpc
from neutron.common import topics
from neutron.common import utils
-from neutron.db import dhcp_rpc_base
from neutron.db import securitygroups_rpc_base as sg_db_rpc
from neutron.extensions import portbindings
from neutron import manager
class RpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
dvr_rpc.DVRServerRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin,
type_tunnel.TunnelRpcCallbackMixin):
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import constants as q_const
svc_constants.L3_ROUTER_NAT: topics.L3PLUGIN}
self.conn = n_rpc.create_connection(new=True)
self.endpoints = [rpc_callbacks.MlnxRpcCallbacks(),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from neutron.common import constants as q_const
from neutron.common import rpc as n_rpc
from neutron.db import api as db_api
-from neutron.db import dhcp_rpc_base
from neutron.db import securitygroups_rpc_base as sg_db_rpc
from neutron.openstack.common import log as logging
from neutron.plugins.mlnx.db import mlnx_db_v2 as db
class MlnxRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
# History
# 1.1 Support Security Group RPC
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api import extensions as neutron_extensions
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes as attrs
from neutron.common import constants as const
from neutron.db import agentschedulers_db
from neutron.db import allowedaddresspairs_db as addr_pair_db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import portbindings_base
from neutron.db import portbindings_db
self.callback_sg = SecurityGroupServerRpcCallback()
self.endpoints = [
NECPluginV2RPCCallbacks(self.safe_reference),
- DhcpRpcCallback(),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
self.callback_sg,
agents_db.AgentExtRpcCallback()]
topic=self.topic_port_update)
-class DhcpRpcCallback(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
- # DhcpPluginApi BASE_RPC_API_VERSION
- RPC_API_VERSION = '1.1'
-
-
class SecurityGroupServerRpcCallback(
n_rpc.RpcCallback,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.common import constants as q_const
from neutron.common import exceptions as nexception
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extraroute_db
from neutron.db import l3_agentschedulers_db
class NVSDPluginRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
RPC_API_VERSION = '1.1'
l3_rpc_agent_api.L3AgentNotifyAPI()
)
self.endpoints = [NVSDPluginRpcCallbacks(),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from neutron.agent import securitygroups_rpc as sg_rpc
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import constants as q_const
from neutron.db import agentschedulers_db
from neutron.db import allowedaddresspairs_db as addr_pair_db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extradhcpopt_db
from neutron.db import extraroute_db
class OVSRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
# history
l3_rpc_agent_api.L3AgentNotifyAPI()
)
self.endpoints = [OVSRpcCallbacks(self.notifier, self.tunnel_type),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback(),
agents_db.AgentExtRpcCallback()]
for svc_topic in self.service_topics.values():
from ryu.app import rest_nw_id
from neutron.agent import securitygroups_rpc as sg_rpc
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.common import constants as q_const
from neutron.common import exceptions as n_exc
from neutron.common import topics
from neutron.db import api as db
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import external_net_db
from neutron.db import extraroute_db
from neutron.db import l3_gwmode_db
class RyuRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin,
sg_db_rpc.SecurityGroupServerRpcCallbackMixin):
RPC_API_VERSION = '1.1'
self.conn = n_rpc.create_connection(new=True)
self.notifier = AgentNotifierApi(topics.AGENT)
self.endpoints = [RyuRpcCallbacks(self.ofp_api_host),
+ dhcp_rpc.DhcpRpcCallback(),
l3_rpc.L3RpcCallback()]
for svc_topic in self.service_topics.values():
self.conn.create_consumer(svc_topic, self.endpoints, fanout=False)
from neutron.api.v2 import attributes
from neutron.common import constants as const
from neutron.common import exceptions as ntn_exc
-from neutron.common import rpc as n_rpc
from neutron.db import db_base_plugin_v2
-from neutron.db import dhcp_rpc_base
from neutron.db import l3_db
from neutron.db import models_v2
from neutron.openstack.common import log as logging
METADATA_DHCP_ROUTE = '169.254.169.254/32'
-class NSXRpcCallbacks(n_rpc.RpcCallback,
- dhcp_rpc_base.DhcpRpcCallbackMixin):
-
- RPC_API_VERSION = '1.1'
-
-
def handle_network_dhcp_access(plugin, context, network, action):
pass
from oslo.config import cfg
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.common import constants as const
from neutron.common import rpc as n_rpc
from neutron.common import topics
def _setup_rpc_dhcp_metadata(self, notifier=None):
self.topic = topics.PLUGIN
self.conn = n_rpc.create_connection(new=True)
- self.endpoints = [nsx_rpc.NSXRpcCallbacks(),
+ self.endpoints = [dhcp_rpc.DhcpRpcCallback(),
agents_db.AgentExtRpcCallback()]
self.conn.create_consumer(self.topic, self.endpoints, fanout=False)
self.agent_notifiers[const.AGENT_TYPE_DHCP] = (
from neutron.api import extensions
from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.api.rpc.handlers import l3_rpc
from neutron.api.v2 import attributes
from neutron.common import constants
from neutron import context
from neutron.db import agents_db
-from neutron.db import dhcp_rpc_base
from neutron.db import l3_agentschedulers_db
from neutron.extensions import agent
from neutron.extensions import dhcpagentscheduler
cfg.CONF.set_override('allow_overlapping_ips', True)
with contextlib.nested(self.subnet(),
self.subnet()):
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
self._register_agent_states()
hosta_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTA)
hostc_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTC)
self._disable_agent(hosta_id)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
# second agent will host all the networks since first is disabled.
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTC)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTC)
networks = self._list_networks_hosted_by_dhcp_agent(hostc_id)
num_hostc_nets = len(networks['networks'])
networks = self._list_networks_hosted_by_dhcp_agent(hosta_id)
cfg.CONF.set_override('allow_overlapping_ips', True)
with contextlib.nested(self.subnet(enable_dhcp=False),
self.subnet(enable_dhcp=False)):
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
self._register_agent_states()
hosta_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTA)
hostc_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTC)
self._disable_agent(hosta_id)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTC)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTC)
networks = self._list_networks_hosted_by_dhcp_agent(hostc_id)
num_hostc_nets = len(networks['networks'])
networks = self._list_networks_hosted_by_dhcp_agent(hosta_id)
cfg.CONF.set_override('allow_overlapping_ips', True)
with contextlib.nested(self.subnet(),
self.subnet()):
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
self._register_agent_states()
hosta_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTA)
hostc_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTC)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTC)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTC)
networks = self._list_networks_hosted_by_dhcp_agent(hostc_id)
num_hostc_nets = len(networks['networks'])
networks = self._list_networks_hosted_by_dhcp_agent(hosta_id)
def test_network_auto_schedule_restart_dhcp_agent(self):
cfg.CONF.set_override('dhcp_agents_per_network', 2)
with self.subnet() as sub1:
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
self._register_agent_states()
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
dhcp_agents = self._list_dhcp_agents_hosting_network(
sub1['subnet']['network_id'])
self.assertEqual(1, len(dhcp_agents['agents']))
cfg.CONF.set_override('allow_overlapping_ips', True)
with contextlib.nested(self.subnet(),
self.subnet()) as (sub1, sub2):
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
self._register_agent_states()
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
# second agent will not host the network since first has got it.
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTC)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTC)
dhcp_agents = self._list_dhcp_agents_hosting_network(
sub1['subnet']['network_id'])
hosta_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
def test_network_auto_schedule_with_hosted_2(self):
# one agent hosts one network
- dhcp_rpc = dhcp_rpc_base.DhcpRpcCallbackMixin()
+ dhcp_rpc_cb = dhcp_rpc.DhcpRpcCallback()
dhcp_hosta = {
'binary': 'neutron-dhcp-agent',
'host': DHCP_HOSTA,
cfg.CONF.set_override('allow_overlapping_ips', True)
with self.subnet() as sub1:
self._register_one_agent_state(dhcp_hosta)
- dhcp_rpc.get_active_networks(self.adminContext, host=DHCP_HOSTA)
+ dhcp_rpc_cb.get_active_networks(self.adminContext, host=DHCP_HOSTA)
hosta_id = self._get_agent_id(constants.AGENT_TYPE_DHCP,
DHCP_HOSTA)
self._disable_agent(hosta_id, admin_state_up=False)
with self.subnet() as sub2:
self._register_one_agent_state(dhcp_hostc)
- dhcp_rpc.get_active_networks(self.adminContext,
+ dhcp_rpc_cb.get_active_networks(self.adminContext,
host=DHCP_HOSTC)
dhcp_agents_1 = self._list_dhcp_agents_hosting_network(
sub1['subnet']['network_id'])
import mock
from oslo.db import exception as db_exc
+from neutron.api.rpc.handlers import dhcp_rpc
from neutron.common import constants
from neutron.common import exceptions as n_exc
-from neutron.db import dhcp_rpc_base
from neutron.tests import base
-class TestDhcpRpcCallbackMixin(base.BaseTestCase):
+class TestDhcpRpcCallback(base.BaseTestCase):
def setUp(self):
- super(TestDhcpRpcCallbackMixin, self).setUp()
+ super(TestDhcpRpcCallback, self).setUp()
self.plugin_p = mock.patch('neutron.manager.NeutronManager.get_plugin')
get_plugin = self.plugin_p.start()
self.plugin = mock.MagicMock()
get_plugin.return_value = self.plugin
- self.callbacks = dhcp_rpc_base.DhcpRpcCallbackMixin()
- self.log_p = mock.patch('neutron.db.dhcp_rpc_base.LOG')
+ self.callbacks = dhcp_rpc.DhcpRpcCallback()
+ self.log_p = mock.patch('neutron.api.rpc.handlers.dhcp_rpc.LOG')
self.log = self.log_p.start()
def test_get_active_networks(self):