Merge "Add support for the agent extension to NVP Plugin."

neutron/plugins/nicira/NeutronPlugin.py

@@ -144,7 +144,9 @@ class NvpPluginV2(db_base_plugin_v2.NeutronDbPluginV2,
     functionality using NVP.
     """
 
-    supported_extension_aliases = ["ext_gw_mode",
+    supported_extension_aliases = ["agent",
+                                   "dhcp_agent_scheduler",
+                                   "ext_gw_mode",
                                    "extraroute",
                                    "mac-learning",
                                    "network-gateway",

neutron/tests/unit/nicira/test_agent_scheduler.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+import os
+
+from neutron.common.test_lib import test_config
+import neutron.plugins.nicira as nvp_plugin
+from neutron.tests.unit.nicira import fake_nvpapiclient
+from neutron.tests.unit.openvswitch import test_agent_scheduler as test_base
+
+
+NVP_MODULE_PATH = nvp_plugin.__name__
+NVP_INI_CONFIG_PATH = os.path.join(os.path.dirname(__file__),
+                                   'etc/nvp.ini.full.test')
+NVP_STUBS_PATH = os.path.join(os.path.dirname(__file__), 'etc')
+
+PLUGIN_NAME = '%s.NeutronPlugin.NvpPluginV2' % nvp_plugin.__name__
+
+
+class NVPDhcpAgentNotifierTestCase(test_base.OvsDhcpAgentNotifierTestCase):
+    plugin_str = PLUGIN_NAME
+
+    def setUp(self):
+        test_config['plugin_name_v2'] = PLUGIN_NAME
+        test_config['config_files'] = [NVP_INI_CONFIG_PATH]
+
+        # mock nvp api client
+        self.fc = fake_nvpapiclient.FakeClient(NVP_STUBS_PATH)
+        self.mock_nvpapi = mock.patch('%s.NvpApiClient.NVPApiHelper'
+                                      % NVP_MODULE_PATH, autospec=True)
+        instance = self.mock_nvpapi.start()
+
+        def _fake_request(*args, **kwargs):
+            return self.fc.fake_request(*args, **kwargs)
+
+        # Emulate tests against NVP 2.x
+        instance.return_value.get_nvp_version.return_value = "2.999"
+        instance.return_value.request.side_effect = _fake_request
+        super(NVPDhcpAgentNotifierTestCase, self).setUp()
+        self.addCleanup(self.fc.reset_all)
+        self.addCleanup(self.mock_nvpapi.stop)
+
+    def _notification_mocks(self, hosts, mock_dhcp, net, subnet, port):
+        host_calls = {}
+        for host in hosts:
+            expected_calls = [
+                mock.call(
+                    mock.ANY,
+                    self.dhcp_notifier.make_msg(
+                        'network_create_end',
+                        payload={'network': net['network']}),
+                    topic='dhcp_agent.' + host),
+                mock.call(
+                    mock.ANY,
+                    self.dhcp_notifier.make_msg(
+                        'subnet_create_end',
+                        payload={'subnet': subnet['subnet']}),
+                    topic='dhcp_agent.' + host),
+                mock.call(
+                    mock.ANY,
+                    self.dhcp_notifier.make_msg(
+                        'port_create_end',
+                        payload={'port': port['port']}),
+                    topic='dhcp_agent.' + host)]
+            host_calls[host] = expected_calls
+        return host_calls

neutron/tests/unit/openvswitch/test_agent_scheduler.py

@@ -1014,87 +1014,58 @@ class OvsDhcpAgentNotifierTestCase(test_l3_plugin.L3NatTestCaseMixin,
                     payload={'admin_state_up': False}),
                 topic='dhcp_agent.' + DHCP_HOSTA)
 
-    def test_network_port_create_notification(self):
+    def _network_port_create(self, hosts):
-        dhcp_hosta = {
+        for host in hosts:
-            'binary': 'neutron-dhcp-agent',
+            self._register_one_agent_state(
-            'host': DHCP_HOSTA,
+                {'binary': 'neutron-dhcp-agent',
-            'topic': 'dhcp_agent',
+                 'host': host,
-            'configurations': {'dhcp_driver': 'dhcp_driver',
+                 'topic': 'dhcp_agent',
-                               'use_namespaces': True,
+                 'configurations': {'dhcp_driver': 'dhcp_driver',
-                               },
+                                    'use_namespaces': True, },
-            'agent_type': constants.AGENT_TYPE_DHCP}
+                 'agent_type': constants.AGENT_TYPE_DHCP})
-        self._register_one_agent_state(dhcp_hosta)
         with mock.patch.object(self.dhcp_notifier, 'cast') as mock_dhcp:
             with self.network(do_delete=False) as net1:
                 with self.subnet(network=net1,
                                  do_delete=False) as subnet1:
                     with self.port(subnet=subnet1, no_delete=True) as port:
-                        network_id = port['port']['network_id']
+                        return [mock_dhcp, net1, subnet1, port]
+
+    def _notification_mocks(self, hosts, mock_dhcp, net, subnet, port):
+        host_calls = {}
+        for host in hosts:
             expected_calls = [
                 mock.call(
                     mock.ANY,
                     self.dhcp_notifier.make_msg(
                         'network_create_end',
-                        payload={'network': {'id': network_id}}),
+                        payload={'network': {'id': net['network']['id']}}),
-                    topic='dhcp_agent.' + DHCP_HOSTA),
+                    topic='dhcp_agent.' + host),
                 mock.call(
                     mock.ANY,
                     self.dhcp_notifier.make_msg(
                         'port_create_end',
                         payload={'port': port['port']}),
-                    topic='dhcp_agent.' + DHCP_HOSTA)]
+                    topic='dhcp_agent.' + host)]
-            self.assertEqual(mock_dhcp.call_args_list, expected_calls)
+            host_calls[host] = expected_calls
+        return host_calls
+
+    def test_network_port_create_notification(self):
+        hosts = [DHCP_HOSTA]
+        [mock_dhcp, net, subnet, port] = self._network_port_create(hosts)
+        expected_calls = self._notification_mocks(hosts, mock_dhcp,
+                                                  net, subnet, port)
+        self.assertEqual(expected_calls[DHCP_HOSTA], mock_dhcp.call_args_list)
 
     def test_network_ha_port_create_notification(self):
         cfg.CONF.set_override('dhcp_agents_per_network', 2)
-        dhcp_hosta = {
+        hosts = [DHCP_HOSTA, DHCP_HOSTC]
-            'binary': 'neutron-dhcp-agent',
+        [mock_dhcp, net, subnet, port] = self._network_port_create(hosts)
-            'host': DHCP_HOSTA,
+        expected_calls = self._notification_mocks(hosts, mock_dhcp,
-            'topic': 'dhcp_agent',
+                                                  net, subnet, port)
-            'configurations': {'dhcp_driver': 'dhcp_driver',
+        for expected in expected_calls[DHCP_HOSTA]:
-                               'use_namespaces': True,
+            self.assertIn(expected, mock_dhcp.call_args_list)
-                               },
+        for expected in expected_calls[DHCP_HOSTC]:
-            'agent_type': constants.AGENT_TYPE_DHCP}
+            self.assertIn(expected, mock_dhcp.call_args_list)
-        self._register_one_agent_state(dhcp_hosta)
-        dhcp_hostc = copy.deepcopy(dhcp_hosta)
-        dhcp_hostc['host'] = DHCP_HOSTC
-        self._register_one_agent_state(dhcp_hostc)
-        with mock.patch.object(self.dhcp_notifier, 'cast') as mock_dhcp:
-            with self.network(do_delete=False) as net1:
-                with self.subnet(network=net1,
-                                 do_delete=False) as subnet1:
-                    with self.port(subnet=subnet1, no_delete=True) as port:
-                        network_id = port['port']['network_id']
-            expected_calls_a = [
-                mock.call(
-                    mock.ANY,
-                    self.dhcp_notifier.make_msg(
-                        'network_create_end',
-                        payload={'network': {'id': network_id}}),
-                    topic='dhcp_agent.' + DHCP_HOSTA),
-                mock.call(
-                    mock.ANY,
-                    self.dhcp_notifier.make_msg(
-                        'port_create_end',
-                        payload={'port': port['port']}),
-                    topic='dhcp_agent.' + DHCP_HOSTA)]
-            expected_calls_c = [
-                mock.call(
-                    mock.ANY,
-                    self.dhcp_notifier.make_msg(
-                        'network_create_end',
-                        payload={'network': {'id': network_id}}),
-                    topic='dhcp_agent.' + DHCP_HOSTC),
-                mock.call(
-                    mock.ANY,
-                    self.dhcp_notifier.make_msg(
-                        'port_create_end',
-                        payload={'port': port['port']}),
-                    topic='dhcp_agent.' + DHCP_HOSTC)]
-            for expected in expected_calls_a:
-                self.assertIn(expected, mock_dhcp.call_args_list)
-            for expected in expected_calls_c:
-                self.assertIn(expected, mock_dhcp.call_args_list)
 
 
 class OvsL3AgentNotifierTestCase(test_l3_plugin.L3NatTestCaseMixin,