continue changes for online

Author: CarolynRountree

core/src/main/python/wlsdeploy/aliases/alias_utils.py

@@ -17,6 +17,7 @@
 from java.lang import RuntimeException
 from java.lang import String
 from java.util import Properties
+from javax.management import ObjectName
 
 from oracle.weblogic.deploy.aliases import TypeUtils
 from oracle.weblogic.deploy.aliases import VersionException
@@ -30,11 +31,13 @@
 from wlsdeploy.aliases.alias_constants import ATTRIBUTES
 from wlsdeploy.aliases.alias_constants import COMMA_DELIMITED_STRING
 from wlsdeploy.aliases.alias_constants import DELIMITED_STRING
+from wlsdeploy.aliases.alias_constants import DICTIONARY
 from wlsdeploy.aliases.alias_constants import JARRAY
 from wlsdeploy.aliases.alias_constants import JAVA_LANG_BOOLEAN
 from wlsdeploy.aliases.alias_constants import LIST
 from wlsdeploy.aliases.alias_constants import LONG
 from wlsdeploy.aliases.alias_constants import PATH_SEPARATOR_DELIMITED_STRING
+from wlsdeploy.aliases.alias_constants import PROPERTIES
 from wlsdeploy.aliases.alias_constants import PREFERRED_MODEL_TYPE
 from wlsdeploy.aliases.alias_constants import SECURITY_PROVIDER_FOLDER_PATHS
 from wlsdeploy.aliases.alias_constants import SECURITY_PROVIDER_MBEAN_NAME_MAP
@@ -626,6 +629,67 @@ def get_number_of_directories_to_strip(desired_path_type, actual_path_type):
     return result
 
 
+def convert_from_type(data_type, value, preferred=None, delimiter=None):
+    """
+    Convert from wlst type
+    :param data_type: type of data
+    :param value: value of data
+    :param preferred: how it should be represented
+    :param delimiter: for representation
+    :return: converted type
+    """
+
+    _method_name = 'convert_from_type'
+    if value is not None and data_type == 'password':
+        # The password is an array of bytes coming back from the WLST get() method and only
+        # java.lang.String() is able to properly convert it to the cipher text string.  However,
+        # we don't really want to return a java.lang.String to the caller so convert that Java
+        # String back to a Python string...ugly but effective.
+        new_value = str(String(value))
+    elif value is not None and isinstance(value, ObjectName):
+        new_value = value.getKeyProperty('Name')
+    else:
+        try:
+            new_value = TypeUtils.convertToType(data_type, value, delimiter)
+        except NumberFormatException, nfe:
+            ex = exception_helper.create_alias_exception('WLSDPLY-08021', value, data_type, delimiter,
+                                                         nfe.getLocalizedMessage(), error=nfe)
+            _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
+            raise ex
+
+        if preferred:
+            delimiter = compute_delimiter_from_data_type(preferred, value)
+        try:
+            if data_type == LONG:
+                new_value = Long(new_value)
+            elif data_type == JAVA_LANG_BOOLEAN:
+                new_value = Boolean(new_value)
+            elif data_type == JARRAY:
+                new_value = _create_array(new_value, delimiter)
+            elif data_type == PROPERTIES:
+                if preferred == DICTIONARY:
+                    new_value =
+            elif data_type == LIST:
+                new_value = list(new_value)
+            elif data_type in (COMMA_DELIMITED_STRING, DELIMITED_STRING, SEMI_COLON_DELIMITED_STRING,
+                               SPACE_DELIMITED_STRING, PATH_SEPARATOR_DELIMITED_STRING):
+                #
+                # This code intentionally ignores the delimiter value passed in and computes it from the data type.
+                # This is required to handle the special case where the value we read from WLST might have a
+                # different delimiter than the model value.  In this use case, the value passed into the method
+                # is the WLST value delimiter and the data_type is the preferred_model_type, so we compute the
+                # model delimiter from the data_type directly.
+                #
+                delimiter = compute_delimiter_from_data_type(data_type, new_value)
+                new_value = delimiter.join(new_value)
+        except TypeError, te:
+            ex = exception_helper.create_alias_exception('WLSDPLY-08021', value, data_type, delimiter, te)
+            _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
+            raise ex
+
+    return new_value
+
+
 def convert_to_type(data_type, value, subtype=None, delimiter=None):
     """
     Convert the value to the specified type.
@@ -661,7 +725,7 @@ def convert_to_type(data_type, value, subtype=None, delimiter=None):
                 new_value = Boolean(new_value)
             elif data_type == JARRAY:
                 if subtype is None or subtype == 'java.lang.String':
-                    new_value = _create_string_array(new_value)
+                    new_value = _create_string_jarray(new_value)
                 else:
                     new_value = _create_mbean_array(new_value, subtype)
             elif data_type == LIST:
@@ -951,7 +1015,7 @@ def _get_value_for_path_type(path_type):
     return result
 
 
-def _create_string_array(iterable):
+def _create_string_jarray(iterable):
     """
     Create a jarray of java.lang.String suitable for WLST attributes that take list objects.
     This is mostly used for WLST online.
@@ -962,11 +1026,38 @@ def _create_string_array(iterable):
     myarray = jarray.zeros(array_len, String)
     idx = 0
     for element in iterable:
-        myarray[idx] = element
+        if isinstance(element, String):
+            myarray[idx] = element
+        elif isinstance(element, ObjectName):
+            myarray[idx] = ObjectName.unquote(element.getKeyProperty('Name'))
+        else:
+            myarray[idx] = str(element)
         idx += 1
     return myarray
 
 
+def _create_array(iterable, delimiter):
+    """
+    Create an array from the jarray objects. If the delimiter is present, convert it to
+    a string with the delimiter.
+    :param iterable: a List object or other iterable type
+    :param delimiter: to create a string from the array
+    :return: an array or a string containing the same contents as the provided iterable
+    """
+    myarray = []
+    for element in iterable:
+        if isinstance(element, ObjectName):
+            myarray.append(element.getKeyProperty('Name'))
+        elif not delimiter or isinstance(element, String):
+            myarray.append(str(element))
+        else:
+            myarray.append(element)
+    if delimiter:
+        # make it to a string
+        myarray = delimiter.join(myarray)
+    return myarray
+
+
 def _create_mbean_array(iterable, subtype):
     """
     Create a jarray of the subtype suitable for WLST attributes that take list objects.

core/src/main/python/wlsdeploy/aliases/aliases.py

@@ -814,7 +814,12 @@ def get_model_attribute_name_and_value(self, location, wlst_attribute_name, wlst
                 alias_utils.compute_read_data_type_and_delimiter_from_attribute_info(attribute_info,
                                                                                      wlst_attribute_value)
 
-            converted_value = alias_utils.convert_to_type(data_type, wlst_attribute_value, delimiter=delimiter)
+            preferred_type = None
+            if PREFERRED_MODEL_TYPE in attribute_info:
+                preferred_type = attribute_info[PREFERRED_MODEL_TYPE]
+            self._logger.fine('wlst attribute {0} data type {1} delimiter {2}')
+            converted_value = alias_utils.convert_from_type(data_type, wlst_attribute_value, delimiter=delimiter,
+                                                            preferred=preferred_type)
             model_attribute_name = attribute_info[MODEL_NAME]
             default_value = attribute_info[VALUE][DEFAULT]
             #

core/src/main/python/wlsdeploy/tool/discover/discoverer.py

@@ -4,6 +4,7 @@
 """
 import javaos as os
 
+from oracle.weblogic.deploy.aliases import AliasException
 from oracle.weblogic.deploy.discover import DiscoverException
 from oracle.weblogic.deploy.util import PyOrderedDict as OrderedDict
 from oracle.weblogic.deploy.util import PyWLSTException
@@ -131,21 +132,38 @@ def _get_attributes_for_current_location_offline(self, location):
 
     def _get_attributes_for_current_location_online(self, location):
         _method_name = '_get_attributes_for_current_location_online'
-        attributes = []
+        attributes = dict()
         path = self._alias_helper.get_wlst_attributes_path(location)
+        added = False
         try:
             attributes = wlst_helper.lsa(path)
             mbean_attributes = wlst_helper.get_mbi().getAttributes()
-            for mbean_attribute in mbean_attributes:
-                name = mbean_attribute.getName()
-                if name not in attributes:
-                    attributes[name] = wlst_helper.get(name)
+            if mbean_attributes:
+                alias_attributes = self._get_wlst_attributes(location)
+                for mbean_attribute in mbean_attributes:
+                    name = mbean_attribute.getName()
+                    if name not in attributes and name in alias_attributes:
+                        attributes[name] = wlst_helper.get(name)
+                        added = True
+                        _logger.fine('Adding attribute {0} value {1}', name, attributes[name])
         except PyWLSTException, pe:
             name = location.get_model_folders()[-1]
             _logger.fine('WLSDPLY-06109', name, str(location), pe.getLocalizedMessage(), class_name=_class_name,
                          method_name=_method_name)
+        if added:
+            for key, value in attributes.iteritems():
+                _logger.fine('attribute list {0}={1}', key, value)
         return attributes
 
+    def _is_defined_attribute(self, location, wlst_name):
+        attribute = False
+        try:
+            if self._aliases.get_model_attribute_name(location, wlst_name):
+                attribute = True
+        except AliasException, ae:
+            pass
+        return attribute
+
     def _get_required_attributes(self, location):
         """
         Use get for all online attributes, and use the attribute names in the
@@ -247,8 +265,13 @@ def _find_subfolders(self, location):
         wlst_path = self._alias_helper.get_wlst_subfolders_path(location)
         self._wlst_helper.cd(wlst_path)
         wlst_subfolders = self._wlst_helper.lsc()
-        if len(wlst_subfolders) == 0:
-            wlst_subfolders = None
+        if wlst_subfolders:
+            new_subfolders = []
+            for wlst_subfolder in wlst_subfolders:
+                model_subfolder_name = self._get_model_name(location, wlst_subfolder)
+                if model_subfolder_name:
+                    new_subfolders.append(wlst_subfolder)
+            wlst_subfolders = new_subfolders
         return wlst_subfolders
 
     def _discover_subfolder_singleton(self, model_subfolder_name, location):
@@ -540,6 +563,19 @@ def _find_mbean_interface(self, location, interfaces):
                 break
         return mbean_name
 
+    def _get_wlst_attributes(self, location):
+        wlst_attributes = []
+        model_attributes = self._alias_helper.get_model_attribute_names(location)
+        if model_attributes:
+            for model_attribute in model_attributes:
+                try:
+                    wlst_attribute = self._aliases.get_wlst_attribute_name(location, model_attribute)
+                    if wlst_attribute:
+                        wlst_attributes.append(wlst_attribute)
+                except AliasException, ae:
+                    continue
+        return wlst_attributes
+
 
 def add_to_model_if_not_empty(dictionary, entry_name, entry_value):
     """

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

@@ -242,8 +242,8 @@ def lsa(path=None, log_throwing=True):
     if wlst.WLS_ON.isConnected() and result and len(result) > 1:
         make_dict = dict()
         for entry in result.entrySet():
-            key = entry.getValue()
-            value = entry.getKey()
+            key = entry.getKey()
+            value = entry.getValue()
             if value is not None and type(value) is str:
                 new_value = value.rstrip()
                 if new_value == 'null':

core/src/main/resources/oracle/weblogic/deploy/aliases/category_modules/SelfTuning.json

@@ -14,7 +14,7 @@
                 "DeploymentOrder": [ {"version": "[10,)", "wlst_mode": "both",    "wlst_name": "DeploymentOrder", "wlst_path": "WP001", "value": {"default": 1000  }, "wlst_type": "integer"          } ],
                 "Notes":           [ {"version": "[10,)", "wlst_mode": "both",    "wlst_name": "Notes",           "wlst_path": "WP001", "value": {"default": "None"}, "wlst_type": "string"           } ],
                 "Target":          [ {"version": "[10,)", "wlst_mode": "offline", "wlst_name": "Target",          "wlst_path": "WP001", "value": {"default": "None"}, "wlst_type": "delimited_string" },
-                                     {"version": "[10,)", "wlst_mode": "online",  "wlst_name": "Targets",         "wlst_path": "WP002", "value": {"default": "None"}, "wlst_type": "jarray",          "set_method": "MBEAN.set_target_mbeans", "set_mbean_type": "weblogic.management.configuration.TargetMBean"} ]
+                                     {"version": "[10,)", "wlst_mode": "online",  "wlst_name": "Targets",         "wlst_path": "WP002", "value": {"default": "None"}, "wlst_type": "jarray",          "preferred_model_type": "delimited_string", "set_method": "MBEAN.set_target_mbeans", "set_mbean_type": "weblogic.management.configuration.TargetMBean"} ]
             },
             "wlst_attributes_path": "WP001",
             "wlst_paths": {