Merge pull request #126 from oracle/Issue#96-online-discover-domain

Issue#96 online discover domain

Author: ddsharpe

core/src/main/java/oracle/weblogic/deploy/aliases/TypeUtils.java

@@ -187,6 +187,9 @@ public static Object convertToType(Class<?> targetType, Object value, String del
             strValue = String.valueOf((char[]) value);
         } else {
             strValue = value.toString().trim();
+            if (strValue.length() == 0) {
+                return null;
+            }
         }
 
         Object result;
@@ -277,6 +280,7 @@ private static Object[] convertToObjectArray(Object value, String strValue, Stri
         } else {
             result = convertStringToList(strValue, delimiter).toArray(new String[0]);
         }
+        LOGGER.fine("before convert {0} and after convert {1}", value, strValue);
         return result;
     }
 

core/src/main/python/discover.py

@@ -25,7 +25,11 @@
 
 sys.path.append(os.path.dirname(os.path.realpath(sys.argv[0])))
 
+from wlsdeploy.aliases import model_constants
+from wlsdeploy.aliases.aliases import Aliases
+from wlsdeploy.aliases.location_context import LocationContext
 import wlsdeploy.tool.util.variable_injector as variable_injector
+
 from wlsdeploy.aliases.wlst_modes import WlstModes
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
@@ -138,7 +142,7 @@ def __process_online_args(optional_arg_map):
                 raise ex
             optional_arg_map[CommandLineArgUtil.ADMIN_PASS_SWITCH] = String(password)
 
-        __logger.info('WLSDPLY-06020', class_name=_class_name, method_name=_method_name)
+        mode = WlstModes.ONLINE
     return mode
 
 
@@ -184,23 +188,28 @@ def __process_variable_filename_arg(optional_arg_map):
     return
 
 
-def __discover(model_context):
+def __discover(model_context, aliases):
     """
     Populate the model from the domain.
     :param model_context: the model context
     :return: the fully-populated model
     :raises DiscoverException: if an error occurred while discover the domain
     """
     _method_name = '__discover'
-
     model = Model()
+    base_location = LocationContext()
     __connect_to_domain(model_context)
     try:
-        DomainInfoDiscoverer(model_context, model.get_model_domain_info(), wlst_mode=__wlst_mode).discover()
-        TopologyDiscoverer(model_context, model.get_model_topology(), wlst_mode=__wlst_mode).discover()
-        ResourcesDiscoverer(model_context, model.get_model_resources(), wlst_mode=__wlst_mode).discover()
-        DeploymentsDiscoverer(model_context, model.get_model_app_deployments(), wlst_mode=__wlst_mode).discover()
-        __discover_multi_tenant(model, model_context)
+        _add_domain_name(base_location, aliases)
+        DomainInfoDiscoverer(model_context, model.get_model_domain_info(), base_location, wlst_mode=__wlst_mode,
+                             aliases=aliases).discover()
+        TopologyDiscoverer(model_context, model.get_model_topology(), base_location, wlst_mode=__wlst_mode,
+                           aliases=aliases).discover()
+        ResourcesDiscoverer(model_context, model.get_model_resources(), base_location, wlst_mode=__wlst_mode,
+                            aliases=aliases).discover()
+        DeploymentsDiscoverer(model_context, model.get_model_app_deployments(), base_location, wlst_mode=__wlst_mode,
+                              aliases=aliases).discover()
+        __discover_multi_tenant(model, model_context, base_location, aliases)
     except AliasException, ae:
         wls_version = WebLogicHelper(__logger).get_actual_weblogic_version()
         wlst_mode = WlstModes.from_value(__wlst_mode)
@@ -214,14 +223,32 @@ def __discover(model_context):
     return model
 
 
-def __discover_multi_tenant(model, model_context):
+def _add_domain_name(location, aliases):
+    _method_name = '_get_domain_name'
+    try:
+        wlst_helper.cd('/')
+        domain_name = wlst_helper.get(model_constants.DOMAIN_NAME)
+    except PyWLSTException, pe:
+        de = exception_helper.create_discover_exception('WLSDPLY-06020', pe.getLocalizedMessage())
+        __logger.throwing(class_name=_class_name, method_name=_method_name, error=de)
+        raise de
+    if domain_name is not None:
+        location.add_name_token(aliases.get_name_token(location), domain_name)
+        __logger.info('WLSDPLY-06022', domain_name, class_name=_class_name, method_name=_method_name)
+    else:
+        de = exception_helper.create_discover_exception('WLSDPLY-WLSDPLY-06023')
+        __logger.throwing(class_name=_class_name, method_name=_method_name, error=de)
+        raise de
+
+
+def __discover_multi_tenant(model, model_context, base_location, aliases):
     """
     Discover the multi-tenant-related parts of the domain, if they exist.
     :param model: the model object to populate
     :param model_context: the model context object
     :raises DiscoverException: if an error occurs during discovery
     """
-    MultiTenantDiscoverer(model, model_context, wlst_mode=__wlst_mode).discover()
+    MultiTenantDiscoverer(model, model_context, base_location, wlst_mode=__wlst_mode, aliases=aliases).discover()
     return
 
 
@@ -381,7 +408,7 @@ def __persist_model(model, model_context):
     return
 
 
-def __check_and_customize_model(model, model_context):
+def __check_and_customize_model(model, model_context, aliases):
     """
     Customize the model dictionary before persisting. Validate the model after customization for informational
     purposes. Any validation errors will not stop the discovered model to be persisted.
@@ -400,7 +427,7 @@ def __check_and_customize_model(model, model_context):
     if inserted:
         model = Model(variable_model)
     try:
-        validator = Validator(model_context, wlst_mode=__wlst_mode)
+        validator = Validator(model_context, wlst_mode=__wlst_mode, aliases=aliases)
 
         # no variables are generated by the discover tool
         validator.validate_in_tool_mode(model.get_model(), variables_file_name=variable_file_name,
@@ -410,14 +437,15 @@ def __check_and_customize_model(model, model_context):
     return model
 
 
-def __log_and_exit(exit_code, class_name, _method_name):
+def __log_and_exit(exit_code, class_name, method_name):
     """
     Helper method to log the exiting message and call sys.exit()
     :param exit_code: the exit code to use
     :param class_name: the class name to pass  to the logger
-    :param _method_name: the method name to pass to the logger
+    :param method_name: the method name to pass to the logger
     """
-    __logger.exiting(result=exit_code, class_name=class_name, method_name=_method_name)
+    __logger.exiting(result=exit_code, class_name=class_name, method_name=method_name)
+
     sys.exit(exit_code)
 
 
@@ -455,16 +483,18 @@ def main(args):
                         ex.getLocalizedMessage(), error=ex, class_name=_class_name, method_name=_method_name)
         __log_and_exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE, _class_name, _method_name)
 
+    aliases = Aliases(model_context, wlst_mode=__wlst_mode)
     model = None
     try:
-        model = __discover(model_context)
+        model = __discover(model_context, aliases)
     except DiscoverException, ex:
         __logger.severe('WLSDPLY-06011', _program_name, model_context.get_domain_name(),
                         model_context.get_domain_home(), ex.getLocalizedMessage(),
                         error=ex, class_name=_class_name, method_name=_method_name)
         __log_and_exit(CommandLineArgUtil.PROG_ERROR_EXIT_CODE, _class_name, _method_name)
-
-    model = __check_and_customize_model(model, model_context)
+        
+    model = __check_and_customize_model(model, model_context, aliases)
+    
     try:
         __persist_model(model, model_context)
 

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

@@ -40,6 +40,7 @@
 WLST_PATH = 'wlst_path'
 WLST_PATHS = 'wlst_paths'
 WLST_READ_TYPE = 'wlst_read_type'
+WLST_SKIP_NAMES = '__wlst_skip_names__'
 WLST_SUBFOLDERS_PATH = 'wlst_subfolders_path'
 WLST_TYPE = 'wlst_type'
 
@@ -106,6 +107,7 @@
 ALIAS_DATA_TYPES.extend(ALIAS_LIST_TYPES)
 ALIAS_DATA_TYPES.extend(ALIAS_MAP_TYPES)
 
+
 def __build_security_provider_data_structures(name_map, base_path):
     """
     Populate the security provider data structures for the given provider type.
@@ -119,6 +121,7 @@ def __build_security_provider_data_structures(name_map, base_path):
         SECURITY_PROVIDER_MBEAN_NAME_MAP[mbean_name] = key
     return
 
+
 ADJUDICATION_PROVIDER_NAME_MAP = {
     'DefaultAdjudicator': 'weblogic.security.providers.authorization.DefaultAdjudicator'
 }

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

@@ -11,12 +11,14 @@
 from oracle.weblogic.deploy.util import FileUtils
 
 import wlsdeploy.aliases.alias_utils as alias_utils
+from wlsdeploy.aliases import password_utils
 from wlsdeploy.aliases.alias_constants import ChildFoldersTypes
 from wlsdeploy.aliases.location_context import LocationContext
 from wlsdeploy.aliases.validation_codes import ValidationCodes
 from wlsdeploy.aliases.wlst_modes import WlstModes
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
+from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
 
 from wlsdeploy.aliases.alias_constants import ATTRIBUTES
@@ -46,9 +48,11 @@
 from wlsdeploy.aliases.alias_constants import WLST_NAMES_MAP
 from wlsdeploy.aliases.alias_constants import WLST_PATH
 from wlsdeploy.aliases.alias_constants import WLST_PATHS
+from wlsdeploy.aliases.alias_constants import WLST_SKIP_NAMES
 from wlsdeploy.aliases.alias_constants import WLST_SUBFOLDERS_PATH
 from wlsdeploy.aliases.alias_constants import WLST_TYPE
 
+IGNORE_FOR_MODEL_LIST = ['DynamicallyCreated', 'Id', 'Tag', 'Tags', 'Type', 'Name']
 _class_name = 'AliasEntries'
 _logger = PlatformLogger('wlsdeploy.aliases')
 
@@ -730,15 +734,17 @@ def get_alias_attribute_entry_by_wlst_name(self, location, wlst_attribute_name):
 
         _logger.entering(str(location), class_name=_class_name, method_name=_method_name)
         folder_dict = self.__get_dictionary_for_location(location, False)
-        if folder_dict is not None and WLST_NAMES_MAP in folder_dict:
+        if self._is_wlst_attribute_skipped(folder_dict, wlst_attribute_name):
+            result = None
+        elif folder_dict is not None and WLST_NAMES_MAP in folder_dict:
             if wlst_attribute_name in folder_dict[WLST_NAMES_MAP]:
                 result = copy.deepcopy(folder_dict[WLST_NAMES_MAP][wlst_attribute_name])
                 if WLST_PATH in result:
                     del result[WLST_PATH]
                 else:
                     _logger.warning('WLSDPLY-08110', wlst_attribute_name, location.get_folder_path(), WLST_PATH)
             else:
-                if wlst_attribute_name not in ('Id', 'Tag', 'Name'):
+                if wlst_attribute_name not in IGNORE_FOR_MODEL_LIST:
                     ex = exception_helper.create_alias_exception('WLSDPLY-08111', location.get_folder_path(),
                                                                  wlst_attribute_name)
                     _logger.throwing(ex, class_name=_class_name, method_name=_method_name)
@@ -1149,6 +1155,7 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
             result_model_attrs = dict()
             result_wlst_attrs = dict()
             unresolved_attrs = dict()
+            wlst_skip_attrs = list()
 
             model_attrs = alias_dict[ATTRIBUTES]
             for model_attr in model_attrs:
@@ -1184,9 +1191,15 @@ def __apply_wlst_context_changes(self, path_name, alias_dict, parent_dict):
                 result_model_attrs[model_attr] = model_attr_dict
                 result_wlst_attrs[wlst_name] = model_attr_dict
 
+                # if attribute is dual-password, add its WLST skip name to the skip list
+                skip_name = password_utils.get_wlst_skip_name(model_attr_dict, self._wlst_mode)
+                if skip_name is not None:
+                    wlst_skip_attrs.append(skip_name)
+
             result[ATTRIBUTES] = result_model_attrs
             result[WLST_NAMES_MAP] = result_wlst_attrs
             result[UNRESOLVED_ATTRIBUTES_MAP] = unresolved_attrs
+            result[WLST_SKIP_NAMES] = wlst_skip_attrs
 
         return result
 
@@ -1364,6 +1377,12 @@ def __get_valid_version_range_for_folder(self, location):
         _logger.exiting(class_name=_class_name, method_name=_method_name, result=version_range)
         return version_range
 
+    def _is_wlst_attribute_skipped(self, folder_dict, wlst_attribute_name):
+        skip_names = dictionary_utils.get_element(folder_dict, WLST_SKIP_NAMES)  # type: list
+        if skip_names is not None:
+            return wlst_attribute_name in skip_names
+        return False
+
     def __get_path_for_location(self, location, path_type=WLST_ATTRIBUTES_PATH):
         """
         Get the tokenized path of the specified type for the location.  This method is used by all path-related methods.