Updates branch sol006 with master

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

diff --git a/osm_lcm/lcm_utils.py b/osm_lcm/lcm_utils.py
index a83e788..dcea3c0 100644 (file)
--- a/osm_lcm/lcm_utils.py
+++ b/osm_lcm/lcm_utils.py
@@ -49,22 +49,50 @@ def versiontuple(v):
     return tuple(filled)
 
 
-def deep_get(target_dict, key_list):
+def deep_get(target_dict, key_list, default_value=None):
     """
     Get a value from target_dict entering in the nested keys. If keys does not exist, it returns None
     Example target_dict={a: {b: 5}}; key_list=[a,b] returns 5; both key_list=[a,b,c] and key_list=[f,h] return None
     :param target_dict: dictionary to be read
     :param key_list: list of keys to read from  target_dict
+    :param default_value: value to return if key is not present in the nested dictionary
     :return: The wanted value if exist, None otherwise
     """
     for key in key_list:
         if not isinstance(target_dict, dict) or key not in target_dict:
-            return None
+            return default_value
         target_dict = target_dict[key]
     return target_dict
 
 
-# LcmBase must be listed before TaskRegistry, as it is a dependency.
+def get_iterable(in_dict, in_key):
+    """
+    Similar to <dict>.get(), but if value is None, False, ..., An empty tuple is returned instead
+    :param in_dict: a dictionary
+    :param in_key: the key to look for at in_dict
+    :return: in_dict[in_var] or () if it is None or not present
+    """
+    if not in_dict.get(in_key):
+        return ()
+    return in_dict[in_key]
+
+
+def populate_dict(target_dict, key_list, value):
+    """
+    Update target_dict creating nested dictionaries with the key_list. Last key_list item is asigned the value.
+    Example target_dict={K: J}; key_list=[a,b,c];  target_dict will be {K: J, a: {b: {c: value}}}
+    :param target_dict: dictionary to be changed
+    :param key_list: list of keys to insert at target_dict
+    :param value:
+    :return: None
+    """
+    for key in key_list[0:-1]:
+        if key not in target_dict:
+            target_dict[key] = {}
+        target_dict = target_dict[key]
+    target_dict[key_list[-1]] = value
+
+
 class LcmBase:
 
     def __init__(self, db, msg, fs, logger):
@@ -237,12 +265,10 @@ class TaskRegistry(LcmBase):
     # Input: op_id, example: 'abc123def:3' Output: account_id='abc123def', op_index=3
     def _get_account_and_op_HA(self, op_id):
         if not op_id:
-            return (None, None)
+            return None, None
         account_id, _, op_index = op_id.rpartition(':')
-        if not account_id:
-            return (None, None)
-        if not op_index.isdigit():
-            return (None, None)
+        if not account_id or not op_index.isdigit():
+            return None, None
         return account_id, op_index
 
     # Get '_id' for any topic and operation
@@ -333,7 +359,7 @@ class TaskRegistry(LcmBase):
             return True
 
         # Try to lock this task
-        db_table_name = self.topic2dbtable_dict.get(topic)
+        db_table_name = self.topic2dbtable_dict[topic]
         q_filter, update_dict = self._get_dbparams_for_lock_HA(topic, op_type, op_id)
         db_lock_task = self.db.set_one(db_table_name,
                                        q_filter=q_filter,
@@ -355,7 +381,7 @@ class TaskRegistry(LcmBase):
                                 fail_on_empty=False)
             return True
 
-    def register_HA(self, topic, op_type, op_id, operationState, detailed_status):
+    def unlock_HA(self, topic, op_type, op_id, operationState, detailed_status):
         """
         Register a task, done when finished a VIM/WIM/SDN 'create' operation.
         :param topic: Can be "vim", "wim", or "sdn"
@@ -365,19 +391,21 @@ class TaskRegistry(LcmBase):
         """
 
         # Backward compatibility
-        if not self._is_account_type_HA(topic) or (self._is_account_type_HA(topic) and op_id is None):
+        if not self._is_account_type_HA(topic) or not op_id:
             return
 
         # Get Account ID and Operation Index
         account_id, op_index = self._get_account_and_op_HA(op_id)
-        db_table_name = self.topic2dbtable_dict.get(topic)
+        db_table_name = self.topic2dbtable_dict[topic]
 
         # If this is a 'delete' operation, the account may have been deleted (SUCCESS) or may still exist (FAILED)
         # If the account exist, register the HA task.
         # Update DB for HA tasks
         q_filter = {'_id': account_id}
         update_dict = {'_admin.operations.{}.operationState'.format(op_index): operationState,
-                       '_admin.operations.{}.detailed-status'.format(op_index): detailed_status}
+                       '_admin.operations.{}.detailed-status'.format(op_index): detailed_status,
+                       '_admin.operations.{}.worker'.format(op_index): None,
+                       '_admin.current_operation': None}
         self.db.set_one(db_table_name,
                         q_filter=q_filter,
                         update_dict=update_dict,
@@ -433,7 +461,7 @@ class TaskRegistry(LcmBase):
                 q_filter = {'_id': _id}
                 # NS/NSI
                 if self._is_service_type_HA(topic):
-                    update_dict = {'detailed-status': step}
+                    update_dict = {'detailed-status': step, 'queuePosition': new_num_related_tasks}
                 # VIM/WIM/SDN
                 elif self._is_account_type_HA(topic):
                     _, op_index = self._get_account_and_op_HA(op_id)