Merge "Remove unused methods in nova/compute/utils.py"

nova/compute/api.py

@@ -3159,7 +3159,7 @@ class API(base.Base):
         project_id, user_id = quotas_obj.ids_from_instance(context,
                                                            instance)
         # Deltas will be empty if the resize is not an upsize.
-        deltas = compute_utils.upsize_quota_delta(context, new_flavor,
+        deltas = compute_utils.upsize_quota_delta(new_flavor,
                                                   current_flavor)
         if deltas:
             try:

nova/compute/utils.py

@@ -767,54 +767,24 @@ def get_machine_ips():
     return addresses
 
 
-def resize_quota_delta(context, new_flavor, old_flavor, sense, compare):
-    """Calculate any quota adjustment required at a particular point
-    in the resize cycle.
+def upsize_quota_delta(new_flavor, old_flavor):
+    """Calculate deltas required to adjust quota for an instance upsize.
 
-    :param context: the request context
     :param new_flavor: the target instance type
     :param old_flavor: the original instance type
-    :param sense: the sense of the adjustment, 1 indicates a
-                  forward adjustment, whereas -1 indicates a
-                  reversal of a prior adjustment
-    :param compare: the direction of the comparison, 1 indicates
-                    we're checking for positive deltas, whereas
-                    -1 indicates negative deltas
     """
     def _quota_delta(resource):
-        return sense * (new_flavor[resource] - old_flavor[resource])
+        return (new_flavor[resource] - old_flavor[resource])
 
     deltas = {}
-    if compare * _quota_delta('vcpus') > 0:
+    if _quota_delta('vcpus') > 0:
         deltas['cores'] = _quota_delta('vcpus')
-    if compare * _quota_delta('memory_mb') > 0:
+    if _quota_delta('memory_mb') > 0:
         deltas['ram'] = _quota_delta('memory_mb')
 
     return deltas
 
 
-def upsize_quota_delta(context, new_flavor, old_flavor):
-    """Calculate deltas required to adjust quota for an instance upsize.
-    """
-    return resize_quota_delta(context, new_flavor, old_flavor, 1, 1)
-
-
-def reverse_upsize_quota_delta(context, instance):
-    """Calculate deltas required to reverse a prior upsizing
-    quota adjustment.
-    """
-    return resize_quota_delta(context, instance.new_flavor,
-                              instance.old_flavor, -1, -1)
-
-
-def downsize_quota_delta(context, instance):
-    """Calculate deltas required to adjust quota for an instance downsize.
-    """
-    old_flavor = instance.get_flavor('old')
-    new_flavor = instance.get_flavor('new')
-    return resize_quota_delta(context, new_flavor, old_flavor, 1, -1)
-
-
 def get_headroom(quotas, usages, deltas):
     headroom = {res: quotas[res] - usages[res]
                 for res in quotas.keys()}

nova/tests/unit/compute/test_compute_api.py

@@ -1896,7 +1896,7 @@ class _ComputeAPIUnitTestMixIn(object):
                                                                fake_inst)
             if flavor_id_passed:
                 compute_utils.upsize_quota_delta(
-                    self.context, mox.IsA(objects.Flavor),
+                    mox.IsA(objects.Flavor),
                     mox.IsA(objects.Flavor)).AndReturn({'cores': 0, 'ram': 0})
 
                 proj_count = {'instances': 1, 'cores': current_flavor.vcpus,
@@ -2245,7 +2245,7 @@ class _ComputeAPIUnitTestMixIn(object):
                 'flavor-id', read_deleted='no').AndReturn(fake_flavor)
         deltas = dict(cores=0)
         compute_utils.upsize_quota_delta(
-            self.context, mox.IsA(objects.Flavor),
+            mox.IsA(objects.Flavor),
             mox.IsA(objects.Flavor)).AndReturn(deltas)
         quotas = {'cores': 0}
         overs = ['cores']

nova/tests/unit/compute/test_compute_utils.py

@@ -1201,38 +1201,7 @@ class ComputeUtilsQuotaTestCase(test.TestCase):
             'ram': new_flavor['memory_mb'] - old_flavor['memory_mb']
         }
 
-        deltas = compute_utils.upsize_quota_delta(self.context, new_flavor,
-                                                  old_flavor)
-        self.assertEqual(expected_deltas, deltas)
-
-    def test_downsize_quota_delta(self):
-        inst = create_instance(self.context, params=None)
-        inst.old_flavor = flavors.get_flavor_by_name('m1.medium')
-        inst.new_flavor = flavors.get_flavor_by_name('m1.tiny')
-
-        expected_deltas = {
-            'cores': (inst.new_flavor['vcpus'] -
-                      inst.old_flavor['vcpus']),
-            'ram': (inst.new_flavor['memory_mb'] -
-                    inst.old_flavor['memory_mb'])
-        }
-
-        deltas = compute_utils.downsize_quota_delta(self.context, inst)
-        self.assertEqual(expected_deltas, deltas)
-
-    def test_reverse_quota_delta(self):
-        inst = create_instance(self.context, params=None)
-        inst.old_flavor = flavors.get_flavor_by_name('m1.tiny')
-        inst.new_flavor = flavors.get_flavor_by_name('m1.medium')
-
-        expected_deltas = {
-            'cores': -1 * (inst.new_flavor['vcpus'] -
-                           inst.old_flavor['vcpus']),
-            'ram': -1 * (inst.new_flavor['memory_mb'] -
-                         inst.old_flavor['memory_mb'])
-        }
-
-        deltas = compute_utils.reverse_upsize_quota_delta(self.context, inst)
+        deltas = compute_utils.upsize_quota_delta(new_flavor, old_flavor)
         self.assertEqual(expected_deltas, deltas)
 
     @mock.patch('nova.objects.Quotas.count_as_dict')