Merge "Fix pci_request_id break the upgrade from icehouse to juno" into proposed/juno

nova/compute/rpcapi.py

@@ -884,7 +884,9 @@ class ComputeAPI(object):
         if not self.client.can_send_version(version):
             version = '3.23'
             if requested_networks is not None:
-                requested_networks = requested_networks.as_tuples()
+                requested_networks = [(network_id, address, port_id)
+                    for (network_id, address, port_id, _) in
+                        requested_networks.as_tuples()]
 
         cctxt = self.client.prepare(server=host, version=version)
         cctxt.cast(ctxt, 'build_and_run_instance', instance=instance,

nova/objects/network_request.py

@@ -44,6 +44,12 @@ class NetworkRequest(obj_base.NovaObject):
             network_id, address, port_id, pci_request_id = net_tuple
             return cls(network_id=network_id, address=address,
                        port_id=port_id, pci_request_id=pci_request_id)
+        elif len(net_tuple) == 3:
+            # NOTE(alex_xu): This is only for compatible with icehouse , and
+            # should be removed in the next cycle.
+            network_id, address, port_id = net_tuple
+            return cls(network_id=network_id, address=address,
+                       port_id=port_id)
         else:
             network_id, address = net_tuple
             return cls(network_id=network_id, address=address)

nova/tests/compute/test_compute_mgr.py

@@ -2067,6 +2067,31 @@ class ComputeManagerBuildInstanceTestCase(test.NoDBTestCase):
                 block_device_mapping=self.block_device_mapping, node=self.node,
                 limits=self.limits)
 
+    # This test when sending an icehouse compatible rpc call to juno compute
+    # node, NetworkRequest object can load from three items tuple.
+    @mock.patch('nova.objects.InstanceActionEvent.event_finish_with_failure')
+    @mock.patch('nova.objects.InstanceActionEvent.event_start')
+    @mock.patch('nova.objects.Instance.save')
+    @mock.patch('nova.compute.manager.ComputeManager._build_and_run_instance')
+    def test_build_and_run_instance_with_icehouse_requested_network(
+            self, mock_build_and_run, mock_save, mock_event_start,
+            mock_event_finish):
+        mock_save.return_value = self.instance
+        self.compute.build_and_run_instance(self.context, self.instance,
+                self.image, request_spec={},
+                filter_properties=self.filter_properties,
+                injected_files=self.injected_files,
+                admin_password=self.admin_pass,
+                requested_networks=[('fake_network_id', '10.0.0.1',
+                                     'fake_port_id')],
+                security_groups=self.security_groups,
+                block_device_mapping=self.block_device_mapping, node=self.node,
+                limits=self.limits)
+        requested_network = mock_build_and_run.call_args[0][5][0]
+        self.assertEqual('fake_network_id', requested_network.network_id)
+        self.assertEqual('10.0.0.1', str(requested_network.address))
+        self.assertEqual('fake_port_id', requested_network.port_id)
+
     def test_build_abort_exception(self):
         self.mox.StubOutWithMock(self.compute, '_build_and_run_instance')
         self.mox.StubOutWithMock(self.compute, '_cleanup_allocated_networks')

nova/tests/compute/test_rpcapi.py

@@ -24,6 +24,7 @@ from oslo.config import cfg
 from nova.compute import rpcapi as compute_rpcapi
 from nova import context
 from nova.objects import block_device as objects_block_dev
+from nova.objects import network_request as objects_network_request
 from nova.openstack.common import jsonutils
 from nova import test
 from nova.tests import fake_block_device
@@ -62,6 +63,14 @@ class ComputeRpcAPITestCase(test.TestCase):
         expected_version = kwargs.pop('version', rpcapi.client.target.version)
 
         expected_kwargs = kwargs.copy()
+        if ('requested_networks' in expected_kwargs and
+               expected_version == '3.23'):
+            expected_kwargs['requested_networks'] = []
+            for requested_network in kwargs['requested_networks']:
+                expected_kwargs['requested_networks'].append(
+                    (requested_network.network_id,
+                     str(requested_network.address),
+                     requested_network.port_id))
         if 'host_param' in expected_kwargs:
             expected_kwargs['host'] = expected_kwargs.pop('host_param')
         else:
@@ -460,3 +469,18 @@ class ComputeRpcAPITestCase(test.TestCase):
                 requested_networks=['network1'], security_groups=None,
                 block_device_mapping=None, node='node', limits=[],
                 version='3.33')
+
+    @mock.patch('nova.utils.is_neutron', return_value=True)
+    def test_build_and_run_instance_icehouse_compat(self, is_neutron):
+        self.flags(compute='icehouse', group='upgrade_levels')
+        self._test_compute_api('build_and_run_instance', 'cast',
+                instance=self.fake_instance_obj, host='host', image='image',
+                request_spec={'request': 'spec'}, filter_properties=[],
+                admin_password='passwd', injected_files=None,
+                requested_networks= objects_network_request.NetworkRequestList(
+                    objects=[objects_network_request.NetworkRequest(
+                        network_id="fake_network_id", address="10.0.0.1",
+                        port_id="fake_port_id")]),
+                security_groups=None,
+                block_device_mapping=None, node='node', limits=[],
+                version='3.23')

nova/tests/objects/test_network_request.py

@@ -56,6 +56,13 @@ class _TestNetworkRequestObject(object):
         self.assertEqual('1.2.3.4', str(request.address))
         self.assertEqual(FAKE_UUID, request.port_id)
 
+    def test_from_tuple_neutron_without_pci_request_id(self):
+        request = objects.NetworkRequest.from_tuple(
+            ('123', '1.2.3.4', FAKE_UUID))
+        self.assertEqual('123', request.network_id)
+        self.assertEqual('1.2.3.4', str(request.address))
+        self.assertEqual(FAKE_UUID, request.port_id)
+
     def test_from_tuple_nova(self):
         request = objects.NetworkRequest.from_tuple(
             ('123', '1.2.3.4'))