Merge "FIP: update_floatingip_status() to return the updated object"

neutron/db/l3_db.py

@@ -1419,7 +1419,7 @@ class L3_NAT_dbonly_mixin(l3.RouterPluginBase,
     @db_api.retry_if_session_inactive()
     def update_floatingip_status(self, context, floatingip_id, status):
         """Update operational status for floating IP in neutron DB."""
-        l3_obj.FloatingIP.update_objects(
+        return l3_obj.FloatingIP.update_object(
             context, {'status': status}, id=floatingip_id)
 
     def _delete_floatingip(self, context, id):

neutron/objects/base.py

@@ -256,14 +256,29 @@ class NeutronObject(obj_base.VersionedObject,
         raise NotImplementedError()
 
     @classmethod
-    def update_objects(cls, context, values, validate_filters=True, **kwargs):
-        objs = cls.get_objects(
-            context, validate_filters=validate_filters, **kwargs)
-        for obj in objs:
+    def _update_objects(cls, objects, values):
+        if not isinstance(objects, collections.Sequence):
+            objects = (objects, )
+
+        for obj in objects:
             for k, v in values.items():
                 setattr(obj, k, v)
             obj.update()
-        return len(objs)
+        return len(objects)
+
+    @classmethod
+    def update_object(cls, context, values, validate_filters=True, **kwargs):
+        obj = cls.get_object(
+            context, validate_filters=validate_filters, **kwargs)
+        if obj:
+            cls._update_objects(obj, values)
+            return obj
+
+    @classmethod
+    def update_objects(cls, context, values, validate_filters=True, **kwargs):
+        objs = cls.get_objects(
+            context, validate_filters=validate_filters, **kwargs)
+        return cls._update_objects(objs, values)
 
     @classmethod
     def delete_objects(cls, context, validate_filters=True, **kwargs):
@@ -545,6 +560,35 @@ class NeutronDbObject(NeutronObject):
             )
             return [cls._load_object(context, db_obj) for db_obj in db_objs]
 
+    @classmethod
+    def update_object(cls, context, values, validate_filters=True, **kwargs):
+        """
+        Update an object that match filtering criteria from DB.
+
+        :param context:
+        :param values: multiple keys to update in matching objects
+        :param validate_filters: Raises an error in case of passing an unknown
+                                 filter
+        :param kwargs: multiple keys defined by key=value pairs
+        :return: The updated version of the object
+        """
+        if validate_filters:
+            cls.validate_filters(**kwargs)
+
+        # if we have standard attributes, we will need to fetch records to
+        # update revision numbers
+        db_obj = None
+        if cls.has_standard_attributes():
+            return super(NeutronDbObject, cls).update_object(
+                context, values, validate_filters=False, **kwargs)
+        else:
+            with db_api.autonested_transaction(context.session):
+                db_obj = obj_db_api.update_object(
+                    context, cls.db_model,
+                    cls.modify_fields_to_db(values),
+                    **cls.modify_fields_to_db(kwargs))
+                return cls._load_object(context, db_obj)
+
     @classmethod
     def update_objects(cls, context, values, validate_filters=True, **kwargs):
         """

neutron/tests/unit/objects/test_base.py

@@ -1862,6 +1862,29 @@ class BaseDbObjectTestCase(_BaseObjectTestCase,
         self.assertTrue(self._test_class.objects_exist(
             self.context, validate_filters=False, fake_filter='xxx'))
 
+    def test_update_object(self):
+        fields_to_update = self.get_updatable_fields(
+            self.obj_fields[1])
+        if not fields_to_update:
+            self.skipTest('No updatable fields found in test '
+                          'class %r' % self._test_class)
+        for fields in self.obj_fields:
+            self._make_object(fields).create()
+
+        obj = self._test_class.get_objects(
+            self.context, **self.valid_field_filter)
+        for k, v in self.valid_field_filter.items():
+            self.assertEqual(v, obj[0][k])
+
+        new_values = self._get_random_update_fields()
+        keys = self.objs[0]._get_composite_keys()
+        updated_obj = self._test_class.update_object(
+            self.context, new_values, **keys)
+
+        # Check the correctness of the updated object
+        for k, v in new_values.items():
+            self.assertEqual(v, updated_obj[k])
+
     def test_update_objects(self):
         fields_to_update = self.get_updatable_fields(
             self.obj_fields[1])