Jira wdt 372 merge models with delete notation (#459)

* JIRA WDT-371 - Use variable map for model merge to find matching names

* JIRA WDT-372 - Check for delete notation differences when merging models

* JIRA WDT-372 - Changed variable name, clarified comments

Author: rakillen

README.md

@@ -16,6 +16,7 @@ Many organizations are using WebLogic Server, with or without other Oracle Fusio
     - [Model Names](#model-names)
     - [Model Semantics](#model-semantics)
     - [Declaring Named MBeans to Delete](#declaring-named-mbeans-to-delete)
+    - [Using Multiple Models](#using-multiple-models)
     - [Administration Server Configuration](site/admin_server.md)
     - [Model Security](site/security.md)
       - [Modeling Security Providers](site/security_providers.md)
@@ -300,6 +301,54 @@ topology:
             ListenPort: 10000  
 ```
 
+If variable properties are used in element names, such as ```@@PROP:my-server@@```, the names in both models will be resolved and matching elements will be merged.
+
+#### Multiple Models and Delete Notation
+
+A named element using [delete notation](#declaring-named-mbeans-to-delete) will completely replace an element with a matching name and no delete notation in a previous model. For example, if Model 1 looks like:
+```yaml
+topology:
+    Server:
+        m1:
+            ListenPort: 7000 
+            Notes: "Server 1"
+```
+and Model 2 looks like:
+```yaml
+topology:
+    Server:
+        !m1:
+```
+The resulting model would be:
+```yaml
+topology:
+    Server:
+        !m1:
+```
+
+Similarly, an element without delete notation will completely replace an element with a matching name that has delete notation in a previous model. For example, if Model 1 looks like:
+```yaml
+topology:
+    Server:
+        !m1:
+```
+and Model 2 looks like:
+```yaml
+topology:
+    Server:
+        m1:
+            ListenPort: 7000 
+            Notes: "Server 1"
+```
+The resulting model would be:
+```yaml
+topology:
+    Server:
+        m1:
+            ListenPort: 7000 
+            Notes: "Server 1"
+```
+
 ## Downloading and Installing the Software
 
 The Oracle WebLogic Server Deploy Tooling project repository is located at [`https://github.com/oracle/weblogic-deploy-tooling`](https://github.com/oracle/weblogic-deploy-tooling).  Binary distributions of the `weblogic-deploy.zip` installer can be downloaded from the [GitHub Releases page](https://github.com/oracle/weblogic-deploy-tooling/releases).  To install the software, simply unzip the `weblogic-deploy.zip` installer on a machine that has the desired versions of WebLogic Server installed.  After being unzipped, the software is ready to use, just set the `JAVA_HOME` environment variable to point to a Java 7 or higher JDK  and the shell scripts are ready to run.

core/src/main/python/wlsdeploy/util/cla_helper.py

@@ -9,6 +9,7 @@
 
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.tool.deploy import deployer_utils
 from wlsdeploy.util import cla_utils
 from wlsdeploy.util import variables
 from wlsdeploy.util.cla_utils import CommandLineArgUtil
@@ -144,9 +145,18 @@ def _merge_dictionaries(dictionary, new_dictionary, variable_map):
     """
     for new_key in new_dictionary:
         new_value = new_dictionary[new_key]
-        dictionary_key = _find_dictionary_key(dictionary, new_key, variable_map)
+        dictionary_key, replace_key = _find_dictionary_merge_key(dictionary, new_key, variable_map)
+
+        # the key is not in the original dictionary, just add it
         if dictionary_key is None:
             dictionary[new_key] = new_value
+
+        # the new key should replace the existing one - delete the existing key and add the new one
+        elif replace_key:
+            del dictionary[dictionary_key]
+            dictionary[new_key] = new_value
+
+        # the key is in both dictionaries - merge if the values are dictionaries, otherwise replace the value
         else:
             value = dictionary[dictionary_key]
             if isinstance(value, dict) and isinstance(new_value, dict):
@@ -155,24 +165,43 @@ def _merge_dictionaries(dictionary, new_dictionary, variable_map):
                 dictionary[new_key] = new_value
 
 
-def _find_dictionary_key(dictionary, new_key, variable_map):
+def _find_dictionary_merge_key(dictionary, new_key, variable_map):
     """
-    Find the specified key in the specified dictionary.
-    If a direct match is not found, and a variable map is specified, perform a more thorough check,
-    taking into account variable substitution.
+    Find the key corresponding to new_key in the specified dictionary.
+    Determine if the new_key should completely replace the value in the dictionary.
+    If no direct match is found, and a variable map is specified, perform check with variable substitution.
+    If keys have the same name, but one has delete notation (!server), that is a match, and replace is true.
     :param dictionary: the dictionary to be searched
     :param new_key: the key being checked
     :param variable_map: variables to be used for name resolution, or None
-    :return: the corresponding key from the dictionary
+    :return: tuple - the corresponding key from the dictionary, True if dictionary key should be replaced
     """
     if new_key in dictionary:
-        return new_key
+        return new_key, False
 
     if variable_map is not None:
-        actual_new_key = variables.substitute_key(new_key, variable_map)
-        for key in dictionary.keys():
-            actual_key = variables.substitute_key(key, variable_map)
-            if actual_key == actual_new_key:
-                return key
+        new_is_delete = deployer_utils.is_delete_name(new_key)
+        match_new_key = _get_merge_match_key(new_key, variable_map)
+
+        for dictionary_key in dictionary.keys():
+            dictionary_is_delete = deployer_utils.is_delete_name(dictionary_key)
+            match_dictionary_key = _get_merge_match_key(dictionary_key, variable_map)
+            if match_dictionary_key == match_new_key:
+                replace_key = new_is_delete != dictionary_is_delete
+                return dictionary_key, replace_key
 
-    return None
+    return None, False
+
+
+def _get_merge_match_key(key, variable_map):
+    """
+    Get the key name to use for matching in model merge.
+    This includes resolving any variables, and removing delete notation if present.
+    :param key: the key to be examined
+    :param variable_map: variable map to use for substitutions
+    :return: the key to use for matching
+    """
+    match_key = variables.substitute_key(key, variable_map)
+    if deployer_utils.is_delete_name(match_key):
+        match_key = deployer_utils.get_delete_item_name(match_key)
+    return match_key

core/src/test/python/wlsdeploy/util/cla_helper_test.py

@@ -99,16 +99,44 @@ def testMergeNameToProperty(self):
 
         self._check_merged_server(dictionary, '@@PROP:server1a@@')
 
+    # an element with delete notation should replace a base element with a matching name and no notation.
+    def testMergeDeletedNameToName(self):
+        dictionary = _build_model_one('m1')
+        new_dictionary = _build_delete_model('m1')
+        variables = {}
+
+        cla_helper._merge_dictionaries(dictionary, new_dictionary, variables)
+        # print("Merged model: " + str(dictionary))
+
+        server = self._check_single_server(dictionary, '!m1')
+        self.assertEquals(0, len(server), "delete server should have no attributes")
+
+    # an element should replace a base element with a matching name and delete notation.
+    def testMergeNameToDeletedName(self):
+        dictionary = _build_delete_model('m1')
+        new_dictionary = _build_model_two('m1')
+        variables = {}
+
+        cla_helper._merge_dictionaries(dictionary, new_dictionary, variables)
+        # print("Merged model: " + str(dictionary))
+
+        server = self._check_single_server(dictionary, 'm1')
+        self.assertEquals(2, len(server), "server should have two attributes")
+
     # check that a single server exists in the result, and its attributes were merged correctly
     def _check_merged_server(self, dictionary, key):
-        servers = dictionary['Servers']
-        self.assertEquals(1, len(servers), "there should be one server")
-
-        server = servers[key]
+        server = self._check_single_server(dictionary, key)
         self.assertEquals(9001, server['ListenPort'], "m1 should have listen port 9001")
         self.assertEquals(5, server['ListenDelaySecs'], "m1 should have listen delay secs 5")
         self.assertEquals(7, server['MaxOpenSockCount'], "m1 should have max open sock count 7")
 
+    # check that a single server exists in the result, with the specified name
+    def _check_single_server(self, dictionary, key):
+        servers = dictionary['Servers']
+        self.assertEquals(1, len(servers), "there should be one server")
+        self.assertEquals(True, key in servers, "the single server name should be " + key)
+        return servers[key]
+
 
 # model 1 has one server with attributes
 def _build_model_one(key):
@@ -134,6 +162,15 @@ def _build_model_two(key):
     }
 
 
+# the delete model 1 has one server with delete notation, and no attributes
+def _build_delete_model(key):
+    return {
+        "Servers": {
+            '!' + key: {}
+        }
+    }
+
+
 # variable map maps two keys to the same server name
 def _build_variable_map():
     return {