Merge "add update method in nb_api and plugin"

dragonflow/db/api_nb.py

@@ -286,6 +286,17 @@ class NbApi(object):
         self._send_db_change_event('secgroup', id, 'create',
                                    secgroup_json, topic)
 
+    def update_security_group(self, id, topic, **columns):
+        secgroup = {}
+        secgroup['id'] = id
+        secgroup['topic'] = topic
+        for col, val in columns.items():
+            secgroup[col] = val
+        secgroup_json = jsonutils.dumps(secgroup)
+        self.driver.set_key('secgroup', id, secgroup_json, topic)
+        self._send_db_change_event('secgroup', id, 'set',
+                                   secgroup_json, topic)
+
     def delete_security_group(self, id, topic):
         self.driver.delete_key('secgroup', id, topic)
         self._send_db_change_event('secgroup', id, 'delete', id,
@@ -493,6 +504,17 @@ class NbApi(object):
         self._send_db_change_event('lrouter', id, 'create', lrouter_json,
                                    topic)
 
+    def update_lrouter(self, id, topic, **columns):
+        lrouter = {}
+        lrouter['id'] = id
+        lrouter['topic'] = topic
+        for col, val in columns.items():
+            lrouter[col] = val
+        lrouter_json = jsonutils.dumps(lrouter)
+        self.driver.set_key('lrouter', id, lrouter_json, topic)
+        self._send_db_change_event('lrouter', id, 'set', lrouter_json,
+                                   topic)
+
     def delete_lrouter(self, id, topic):
         self.driver.delete_key('lrouter', id, topic)
         self._send_db_change_event('lrouter', id, 'delete', id,

dragonflow/neutron/plugin.py

@@ -229,6 +229,24 @@ class DFPlugin(db_base_plugin_v2.NeutronDbPluginV2,
                                           version=sg_version)
         return sg_db
 
+    @lock_db.wrap_db_lock()
+    def update_security_group(self, context, sg_id, security_group):
+        with context.session.begin(subtransactions=True):
+            sg_db = super(DFPlugin,
+                          self).update_security_group(context, sg_id,
+                                                      security_group)
+            sg_version = version_db._update_db_version_row(
+                    context.session, sg_id)
+
+        sg_name = sg_db.get('name', df_const.DF_SG_DEFAULT_NAME)
+        tenant_id = sg_db['tenant_id']
+        rules = sg_db.get('security_group_rules')
+
+        self.nb_api.update_security_group(id=sg_id, topic=tenant_id,
+                                          name=sg_name, rules=rules,
+                                          version=sg_version)
+        return sg_db
+
     @lock_db.wrap_db_lock()
     def create_security_group_rule(self, context, security_group_rule):
         with context.session.begin(subtransactions=True):
@@ -751,6 +769,23 @@ class DFPlugin(db_base_plugin_v2.NeutronDbPluginV2,
                                    ports=[])
         return router
 
+    @lock_db.wrap_db_lock()
+    def update_router(self, context, id, router):
+        with context.session.begin(subtransactions=True):
+            router = super(DFPlugin, self).update_router(
+                context, id, router)
+            router_version = version_db._update_db_version_row(
+                    context.session, id)
+
+        tenant_id = router['tenant_id']
+        is_distributed = router.get('distributed', False)
+        router_name = router.get('name', df_const.DF_ROUTER_DEFAULT_NAME)
+        self.nb_api.update_lrouter(id, topic=tenant_id,
+                                   name=router_name,
+                                   distributed=is_distributed,
+                                   version=router_version)
+        return router
+
     @lock_db.wrap_db_lock()
     def delete_router(self, context, router_id):
         router = self.get_router(context, router_id)

dragonflow/tests/fullstack/test_neutron_api.py

@@ -84,8 +84,13 @@ class TestNeutronAPIandDB(test_base.DFTestBase):
 
     def test_create_delete_router(self):
         router = self.store(objects.RouterTestObj(self.neutron, self.nb_api))
-        router.create()
+        router_id = router.create()
         self.assertTrue(router.exists())
+        version1 = self.nb_api.get_router(router_id).get_version()
+        router.update()
+        self.assertTrue(router.exists())
+        version2 = self.nb_api.get_router(router_id).get_version()
+        self.assertTrue(version1 != version2)
         router.close()
         self.assertFalse(router.exists())
 
@@ -175,8 +180,13 @@ class TestNeutronAPIandDB(test_base.DFTestBase):
     def test_create_delete_security_group(self):
         secgroup = self.store(
                         objects.SecGroupTestObj(self.neutron, self.nb_api))
-        secgroup.create()
+        sg_id = secgroup.create()
         self.assertTrue(secgroup.exists())
+        version1 = self.nb_api.get_security_group(sg_id).get_version()
+        secgroup.update()
+        self.assertTrue(secgroup.exists())
+        version2 = self.nb_api.get_security_group(sg_id).get_version()
+        self.assertTrue(version1 != version2)
         secgroup.close()
         self.assertFalse(secgroup.exists())
 

dragonflow/tests/fullstack/test_objects.py

@@ -62,6 +62,11 @@ class RouterTestObj(object):
         self.router_id = new_router['router']['id']
         return self.router_id
 
+    def update(self, router={'name': 'myrouter2'}):
+        router = self.neutron.update_router(
+                self.router_id, {'router': router})
+        return router['router']
+
     def close(self):
         if self.closed or self.router_id is None:
             return
@@ -109,6 +114,11 @@ class SecGroupTestObj(object):
         self.secgroup_id = new_secgroup['security_group']['id']
         return self.secgroup_id
 
+    def update(self, secgroup={'name': 'mysecgroup2'}):
+        update_secgroup = self.neutron.update_security_group(
+                self.secgroup_id, {'security_group': secgroup})
+        return update_secgroup['security_group']
+
     def close(self):
         if self.closed or self.secgroup_id is None:
             return