fix bug 802 decrypt vrops_password at vim_account for schema_version>=1.1

[osm/LCM.git] / osm_lcm / vim_sdn.py

diff --git a/osm_lcm/vim_sdn.py b/osm_lcm/vim_sdn.py
index 07aa4a9..3fb24aa 100644 (file)
--- a/osm_lcm/vim_sdn.py
+++ b/osm_lcm/vim_sdn.py
@@ -29,7 +29,8 @@ __author__ = "Alfonso Tierno"
 
 class VimLcm(LcmBase):
     # values that are encrypted at vim config because they are passwords
-    vim_config_encrypted = ("admin_password", "nsx_password", "vcenter_password")
+    vim_config_encrypted = {"1.1": ("admin_password", "nsx_password", "vcenter_password"),
+                            "default": ("admin_password", "nsx_password", "vcenter_password", "vrops_password")}
 
     def __init__(self, db, msg, fs, lcm_tasks, ro_config, loop):
         """
@@ -47,6 +48,7 @@ class VimLcm(LcmBase):
 
     async def create(self, vim_content, order_id):
         vim_id = vim_content["_id"]
+        vim_content.pop("op_id", None)
         logging_text = "Task vim_create={} ".format(vim_id)
         self.logger.debug(logging_text + "Enter")
         db_vim = None
@@ -56,7 +58,6 @@ class VimLcm(LcmBase):
         try:
             step = "Getting vim-id='{}' from db".format(vim_id)
             db_vim = self.db.get_one("vim_accounts", {"_id": vim_id})
-            db_vim_update["_admin.deployed.RO"] = None
             if vim_content.get("config") and vim_content["config"].get("sdn-controller"):
                 step = "Getting sdn-controller-id='{}' from db".format(vim_content["config"]["sdn-controller"])
                 db_sdn = self.db.get_one("sdns", {"_id": vim_content["config"]["sdn-controller"]})
@@ -67,6 +68,7 @@ class VimLcm(LcmBase):
                         vim_content["config"]["sdn-controller"]))
 
             step = "Creating vim at RO"
+            db_vim_update["_admin.deployed.RO"] = None
             db_vim_update["_admin.detailed-status"] = step
             self.update_db_2("vim_accounts", vim_id, db_vim_update)
             RO = ROclient.ROClient(self.loop, **self.ro_config)
@@ -104,7 +106,9 @@ class VimLcm(LcmBase):
                     del vim_account_RO["config"]["sdn-controller"]
                 if "sdn-port-mapping" in vim_account_RO["config"]:
                     del vim_account_RO["config"]["sdn-port-mapping"]
-                for p in self.vim_config_encrypted:
+                vim_config_encrypted_keys = self.vim_config_encrypted.get(schema_version) or \
+                    self.vim_config_encrypted.get("default")
+                for p in vim_config_encrypted_keys:
                     if vim_account_RO["config"].get(p):
                         vim_account_RO["config"][p] = self.db.decrypt(vim_account_RO["config"][p],
                                                                       schema_version=schema_version,
@@ -129,12 +133,17 @@ class VimLcm(LcmBase):
             if exc and db_vim:
                 db_vim_update["_admin.operationalState"] = "ERROR"
                 db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_vim_update:
-                self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            try:
+                if db_vim_update:
+                    self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
+
             self.lcm_tasks.remove("vim_account", vim_id, order_id)
 
     async def edit(self, vim_content, order_id):
         vim_id = vim_content["_id"]
+        vim_content.pop("op_id", None)
         logging_text = "Task vim_edit={} ".format(vim_id)
         self.logger.debug(logging_text + "Enter")
         db_vim = None
@@ -217,7 +226,9 @@ class VimLcm(LcmBase):
                 if "config" in vim_content:
                     vim_account_RO["config"] = vim_content["config"]
                 if vim_content.get("config"):
-                    for p in self.vim_config_encrypted:
+                    vim_config_encrypted_keys = self.vim_config_encrypted.get(schema_version) or \
+                        self.vim_config_encrypted.get("default")
+                    for p in vim_config_encrypted_keys:
                         if vim_content["config"].get(p):
                             vim_account_RO["config"][p] = self.db.decrypt(vim_content["config"][p],
                                                                           schema_version=schema_version,
@@ -243,8 +254,12 @@ class VimLcm(LcmBase):
             if exc and db_vim:
                 db_vim_update["_admin.operationalState"] = "ERROR"
                 db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_vim_update:
-                self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            try:
+                if db_vim_update:
+                    self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
+
             self.lcm_tasks.remove("vim_account", vim_id, order_id)
 
     async def delete(self, vim_id, order_id):
@@ -280,6 +295,7 @@ class VimLcm(LcmBase):
                 # nothing to delete
                 self.logger.error(logging_text + "Nohing to remove at RO")
             self.db.del_one("vim_accounts", {"_id": vim_id})
+            db_vim = None
             self.logger.debug(logging_text + "Exit Ok")
             return
 
@@ -294,8 +310,11 @@ class VimLcm(LcmBase):
             if exc and db_vim:
                 db_vim_update["_admin.operationalState"] = "ERROR"
                 db_vim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_vim_update:
-                self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            try:
+                if db_vim and db_vim_update:
+                    self.update_db_2("vim_accounts", vim_id, db_vim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("vim_account", vim_id, order_id)
 
 
@@ -319,6 +338,7 @@ class WimLcm(LcmBase):
 
     async def create(self, wim_content, order_id):
         wim_id = wim_content["_id"]
+        wim_content.pop("op_id", None)
         logging_text = "Task wim_create={} ".format(wim_id)
         self.logger.debug(logging_text + "Enter")
         db_wim = None
@@ -387,12 +407,16 @@ class WimLcm(LcmBase):
             if exc and db_wim:
                 db_wim_update["_admin.operationalState"] = "ERROR"
                 db_wim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_wim_update:
-                self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            try:
+                if db_wim_update:
+                    self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("wim_account", wim_id, order_id)
 
     async def edit(self, wim_content, order_id):
         wim_id = wim_content["_id"]
+        wim_content.pop("op_id", None)
         logging_text = "Task wim_edit={} ".format(wim_id)
         self.logger.debug(logging_text + "Enter")
         db_wim = None
@@ -476,8 +500,11 @@ class WimLcm(LcmBase):
             if exc and db_wim:
                 db_wim_update["_admin.operationalState"] = "ERROR"
                 db_wim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_wim_update:
-                self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            try:
+                if db_wim_update:
+                    self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("wim_account", wim_id, order_id)
 
     async def delete(self, wim_id, order_id):
@@ -513,6 +540,7 @@ class WimLcm(LcmBase):
                 # nothing to delete
                 self.logger.error(logging_text + "Nohing to remove at RO")
             self.db.del_one("wim_accounts", {"_id": wim_id})
+            db_wim = None
             self.logger.debug(logging_text + "Exit Ok")
             return
 
@@ -527,8 +555,11 @@ class WimLcm(LcmBase):
             if exc and db_wim:
                 db_wim_update["_admin.operationalState"] = "ERROR"
                 db_wim_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_wim_update:
-                self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            try:
+                if db_wim and db_wim_update:
+                    self.update_db_2("wim_accounts", wim_id, db_wim_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("wim_account", wim_id, order_id)
 
 
@@ -550,6 +581,7 @@ class SdnLcm(LcmBase):
 
     async def create(self, sdn_content, order_id):
         sdn_id = sdn_content["_id"]
+        sdn_content.pop("op_id", None)
         logging_text = "Task sdn_create={} ".format(sdn_id)
         self.logger.debug(logging_text + "Enter")
         db_sdn = None
@@ -562,6 +594,9 @@ class SdnLcm(LcmBase):
             db_sdn_update["_admin.deployed.RO"] = None
 
             step = "Creating sdn at RO"
+            db_sdn_update["_admin.detailed-status"] = step
+            self.update_db_2("sdns", sdn_id, db_sdn_update)
+
             RO = ROclient.ROClient(self.loop, **self.ro_config)
             sdn_RO = deepcopy(sdn_content)
             sdn_RO.pop("_id", None)
@@ -589,12 +624,16 @@ class SdnLcm(LcmBase):
             if exc and db_sdn:
                 db_sdn_update["_admin.operationalState"] = "ERROR"
                 db_sdn_update["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_sdn_update:
-                self.update_db_2("sdns", sdn_id, db_sdn_update)
+            try:
+                if db_sdn and db_sdn_update:
+                    self.update_db_2("sdns", sdn_id, db_sdn_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("sdn", sdn_id, order_id)
 
     async def edit(self, sdn_content, order_id):
         sdn_id = sdn_content["_id"]
+        sdn_content.pop("op_id", None)
         logging_text = "Task sdn_edit={} ".format(sdn_id)
         self.logger.debug(logging_text + "Enter")
         db_sdn = None
@@ -633,8 +672,11 @@ class SdnLcm(LcmBase):
             if exc and db_sdn:
                 db_sdn["_admin.operationalState"] = "ERROR"
                 db_sdn["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_sdn_update:
-                self.update_db_2("sdns", sdn_id, db_sdn_update)
+            try:
+                if db_sdn_update:
+                    self.update_db_2("sdns", sdn_id, db_sdn_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("sdn", sdn_id, order_id)
 
     async def delete(self, sdn_id, order_id):
@@ -661,6 +703,7 @@ class SdnLcm(LcmBase):
                 # nothing to delete
                 self.logger.error(logging_text + "Skipping. There is not RO information at database")
             self.db.del_one("sdns", {"_id": sdn_id})
+            db_sdn = None
             self.logger.debug("sdn_delete task sdn_id={} Exit Ok".format(sdn_id))
             return
 
@@ -674,6 +717,9 @@ class SdnLcm(LcmBase):
             if exc and db_sdn:
                 db_sdn["_admin.operationalState"] = "ERROR"
                 db_sdn["_admin.detailed-status"] = "ERROR {}: {}".format(step, exc)
-            if db_sdn_update:
-                self.update_db_2("sdns", sdn_id, db_sdn_update)
+            try:
+                if db_sdn and db_sdn_update:
+                    self.update_db_2("sdns", sdn_id, db_sdn_update)
+            except DbException as e:
+                self.logger.error(logging_text + "Cannot update database: {}".format(e))
             self.lcm_tasks.remove("sdn", sdn_id, order_id)