Merge "Prepare _heal_allocations_for_instance for nested allocations"

Zuul · openstack-gerrit · commit 42df3eaf1f3e · 2019-06-27T21:33:43.000Z
diff --git a/nova/cmd/manage.py b/nova/cmd/manage.py
@@ -1674,10 +1674,16 @@ def _heal_missing_alloc(
                    {'instance': instance.uuid, 'node_uuid': node_uuid,
                     'resources': resources})
         else:
-            if placement.put_allocations(
-                    ctxt, node_uuid, instance.uuid, resources,
-                    instance.project_id, instance.user_id,
-                    consumer_generation=None):
+            payload = {
+                'allocations': {
+                    node_uuid: {'resources': resources},
+                },
+                'project_id': instance.project_id,
+                'user_id': instance.user_id,
+                'consumer_generation': None
+            }
+            resp = placement.put_allocations(ctxt, instance.uuid, payload)
+            if resp:
                 output(_('Successfully created allocations for '
                          'instance %(instance)s against resource '
                          'provider %(provider)s.') %
@@ -1688,21 +1694,16 @@ def _heal_missing_alloc(
                     instance=instance.uuid, provider=node_uuid)
 
     def _heal_missing_project_and_user_id(
-            self, allocations, instance, dry_run, output, placement):
+            self, ctxt, allocations, instance, dry_run, output, placement):
 
         allocations['project_id'] = instance.project_id
         allocations['user_id'] = instance.user_id
-        # We use CONSUMER_GENERATION_VERSION for PUT
-        # /allocations/{consumer_id} to mirror the body structure from
-        # get_allocs_for_consumer.
         if dry_run:
             output(_('[dry-run] Update allocations for instance '
                      '%(instance)s: %(allocations)s') %
                    {'instance': instance.uuid, 'allocations': allocations})
         else:
-            resp = placement.put(
-                '/allocations/%s' % instance.uuid,
-                allocations, version=report.CONSUMER_GENERATION_VERSION)
+            resp = placement.put_allocations(ctxt, instance.uuid, allocations)
             if resp:
                 output(_('Successfully updated allocations for '
                          'instance %s.') % instance.uuid)
@@ -1772,7 +1773,7 @@ def _heal_allocations_for_instance(self, ctxt, instance, node_cache,
             # because we don't want to mess up shared or nested
             # provider allocations.
             return self._heal_missing_project_and_user_id(
-                allocations, instance, dry_run, output, placement)
+                ctxt, allocations, instance, dry_run, output, placement)
 
         output(_('Instance %s already has allocations with '
                  'matching consumer project/user.') % instance.uuid)
diff --git a/nova/scheduler/client/report.py b/nova/scheduler/client/report.py
@@ -1930,42 +1930,24 @@ def move_allocations(self, context, source_consumer_uuid,
                      'text': r.text})
         return r.status_code == 204
 
+    # TODO(gibi): kill safe_connect
     @safe_connect
     @retries
-    def put_allocations(self, context, rp_uuid, consumer_uuid, alloc_data,
-                        project_id, user_id, consumer_generation):
-        """Creates allocation records for the supplied instance UUID against
-        the supplied resource provider.
-
-        :note Currently we only allocate against a single resource provider.
-              Once shared storage and things like NUMA allocations are a
-              reality, this will change to allocate against multiple providers.
+    def put_allocations(self, context, consumer_uuid, payload):
+        """Creates allocation records for the supplied consumer UUID based on
+        the provided allocation dict
 
         :param context: The security context
-        :param rp_uuid: The UUID of the resource provider to allocate against.
         :param consumer_uuid: The instance's UUID.
-        :param alloc_data: Dict, keyed by resource class, of amounts to
-                           consume.
-        :param project_id: The project_id associated with the allocations.
-        :param user_id: The user_id associated with the allocations.
-        :param consumer_generation: The current generation of the consumer or
-                                    None if this the initial allocation of the
-                                    consumer
+        :param payload: Dict in the format expected by the placement
+            PUT /allocations/{consumer_uuid} API
         :returns: True if the allocations were created, False otherwise.
         :raises: Retry if the operation should be retried due to a concurrent
                  resource provider update.
         :raises: AllocationUpdateFailed if placement returns a consumer
                                         generation conflict
         """
 
-        payload = {
-            'allocations': {
-                rp_uuid: {'resources': alloc_data},
-            },
-            'project_id': project_id,
-            'user_id': user_id,
-            'consumer_generation': consumer_generation
-        }
         r = self._put_allocations(context, consumer_uuid, payload)
         if r.status_code != 204:
             err = r.json()['errors'][0]
diff --git a/nova/tests/functional/test_report_client.py b/nova/tests/functional/test_report_client.py
@@ -243,10 +243,16 @@ def test_client_report_smoke(self):
             # Update allocations with our instance
             alloc_dict = utils.resources_from_flavor(self.instance,
                                                      self.instance.flavor)
+            payload = {
+                "allocations": {
+                    self.compute_uuid: {"resources": alloc_dict}
+                },
+                "project_id": self.instance.project_id,
+                "user_id": self.instance.user_id,
+                "consumer_generation": None
+            }
             self.client.put_allocations(
-                self.context, self.compute_uuid, self.instance_uuid,
-                alloc_dict, self.instance.project_id, self.instance.user_id,
-                None)
+                self.context, self.instance_uuid, payload)
 
             # Check that allocations were made
             resp = self.client.get('/allocations/%s' % self.instance_uuid)
@@ -685,13 +691,18 @@ def test_set_inventory_for_provider(self):
                 inv,
                 self.client._get_inventory(
                     self.context, uuids.cn)['inventories'])
-
+            payload = {
+                "allocations": {
+                    uuids.cn: {"resources": {orc.SRIOV_NET_VF: 1}}
+                },
+                "project_id": uuids.proj,
+                "user_id": uuids.user,
+                "consumer_generation": None
+            }
             # Now set up an InventoryInUse case by creating a VF allocation...
             self.assertTrue(
                 self.client.put_allocations(
-                    self.context, uuids.cn, uuids.consumer,
-                    {orc.SRIOV_NET_VF: 1},
-                    uuids.proj, uuids.user, None))
+                    self.context, uuids.consumer, payload))
             # ...and trying to delete the provider's VF inventory
             bad_inv = {
                 'CUSTOM_BANDWIDTH': {
diff --git a/nova/tests/unit/scheduler/client/test_report.py b/nova/tests/unit/scheduler/client/test_report.py
@@ -269,14 +269,19 @@ def test_put_allocations(self, mock_put):
         consumer_uuid = mock.sentinel.consumer
         data = {"MEMORY_MB": 1024}
         expected_url = "/allocations/%s" % consumer_uuid
-        resp = self.client.put_allocations(self.context, rp_uuid,
-                                           consumer_uuid, data,
-                                           mock.sentinel.project_id,
-                                           mock.sentinel.user_id,
-                                           mock.sentinel.consumer_generation)
+        payload = {
+            "allocations": {
+                rp_uuid: {"resources": data}
+            },
+            "project_id": mock.sentinel.project_id,
+            "user_id": mock.sentinel.user_id,
+            "consumer_generation": mock.sentinel.consumer_generation
+        }
+        resp = self.client.put_allocations(
+            self.context, consumer_uuid, payload)
         self.assertTrue(resp)
         mock_put.assert_called_once_with(
-            expected_url, mock.ANY, version='1.28',
+            expected_url, payload, version='1.28',
             global_request_id=self.context.global_id)
 
     @mock.patch.object(report.LOG, 'warning')
@@ -288,14 +293,20 @@ def test_put_allocations_fail(self, mock_put, mock_warn):
         consumer_uuid = mock.sentinel.consumer
         data = {"MEMORY_MB": 1024}
         expected_url = "/allocations/%s" % consumer_uuid
-        resp = self.client.put_allocations(self.context, rp_uuid,
-                                           consumer_uuid, data,
-                                           mock.sentinel.project_id,
-                                           mock.sentinel.user_id,
-                                           mock.sentinel.consumer_generation)
+        payload = {
+            "allocations": {
+                rp_uuid: {"resources": data}
+            },
+            "project_id": mock.sentinel.project_id,
+            "user_id": mock.sentinel.user_id,
+            "consumer_generation": mock.sentinel.consumer_generation
+        }
+        resp = self.client.put_allocations(
+            self.context, consumer_uuid, payload)
+
         self.assertFalse(resp)
         mock_put.assert_called_once_with(
-            expected_url, mock.ANY, version='1.28',
+            expected_url, payload, version='1.28',
             global_request_id=self.context.global_id)
         log_msg = mock_warn.call_args[0][0]
         self.assertIn("Failed to save allocation for", log_msg)
@@ -313,13 +324,17 @@ def test_put_allocations_fail_due_to_consumer_generation_conflict(
         consumer_uuid = mock.sentinel.consumer
         data = {"MEMORY_MB": 1024}
         expected_url = "/allocations/%s" % consumer_uuid
+        payload = {
+            "allocations": {
+                rp_uuid: {"resources": data}
+            },
+            "project_id": mock.sentinel.project_id,
+            "user_id": mock.sentinel.user_id,
+            "consumer_generation": mock.sentinel.consumer_generation
+        }
         self.assertRaises(exception.AllocationUpdateFailed,
                           self.client.put_allocations,
-                          self.context, rp_uuid,
-                          consumer_uuid, data,
-                          mock.sentinel.project_id,
-                          mock.sentinel.user_id,
-                          mock.sentinel.consumer_generation)
+                          self.context, consumer_uuid, payload)
 
         mock_put.assert_called_once_with(
             expected_url, mock.ANY, version='1.28',
@@ -343,14 +358,19 @@ def test_put_allocations_retries_conflict(self, mock_put):
         consumer_uuid = mock.sentinel.consumer
         data = {"MEMORY_MB": 1024}
         expected_url = "/allocations/%s" % consumer_uuid
-        resp = self.client.put_allocations(self.context, rp_uuid,
-                                           consumer_uuid, data,
-                                           mock.sentinel.project_id,
-                                           mock.sentinel.user_id,
-                                           mock.sentinel.consumer_generation)
+        payload = {
+            "allocations": {
+                rp_uuid: {"resources": data}
+            },
+            "project_id": mock.sentinel.project_id,
+            "user_id": mock.sentinel.user_id,
+            "consumer_generation": mock.sentinel.consumer_generation
+        }
+        resp = self.client.put_allocations(
+            self.context, consumer_uuid, payload)
         self.assertTrue(resp)
         mock_put.assert_has_calls([
-            mock.call(expected_url, mock.ANY, version='1.28',
+            mock.call(expected_url, payload, version='1.28',
                       global_request_id=self.context.global_id)] * 2)
 
     @mock.patch('time.sleep', new=mock.Mock())
@@ -369,14 +389,19 @@ def test_put_allocations_retry_gives_up(self, mock_put):
         consumer_uuid = mock.sentinel.consumer
         data = {"MEMORY_MB": 1024}
         expected_url = "/allocations/%s" % consumer_uuid
-        resp = self.client.put_allocations(self.context, rp_uuid,
-                                           consumer_uuid, data,
-                                           mock.sentinel.project_id,
-                                           mock.sentinel.user_id,
-                                           mock.sentinel.consumer_generation)
+        payload = {
+            "allocations": {
+                rp_uuid: {"resources": data}
+            },
+            "project_id": mock.sentinel.project_id,
+            "user_id": mock.sentinel.user_id,
+            "consumer_generation": mock.sentinel.consumer_generation
+        }
+        resp = self.client.put_allocations(
+            self.context, consumer_uuid, payload)
         self.assertFalse(resp)
         mock_put.assert_has_calls([
-            mock.call(expected_url, mock.ANY, version='1.28',
+            mock.call(expected_url, payload, version='1.28',
             global_request_id=self.context.global_id)] * 3)
 
     def test_claim_resources_success(self):
diff --git a/nova/tests/unit/test_nova_manage.py b/nova/tests/unit/test_nova_manage.py
