change all discover interfaces to receive a base location and aliases instance

Author: CarolynRountree

core/src/main/python/discover.py

@@ -26,6 +26,9 @@
 
 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
 from wlsdeploy.aliases.wlst_modes import WlstModes
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.logging.platform_logger import PlatformLogger
@@ -135,7 +138,7 @@ def __process_online_args(optional_arg_map):
                 raise ex
             optional_arg_map[CommandLineArgUtil.ADMIN_PASS_SWITCH] = String(password)
 
-        __logger.info('WLSDPLY-06020')
+        mode = WlstModes.ONLINE
     return mode
 
 
@@ -159,23 +162,28 @@ def __process_archive_filename_arg(required_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)
@@ -189,14 +197,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-06021')
+        __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
 
 
@@ -356,7 +382,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.
@@ -368,25 +394,24 @@ def __check_and_customize_model(model, model_context):
     if filter_helper.apply_filters(model.get_model(), "discover"):
         __logger.info('WLSDPLY-06014', _class_name=_class_name, method_name=_method_name)
 
-
     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=None,
-                                                      archive_file_name=model_context.get_archive_file_name())
+                                        archive_file_name=model_context.get_archive_file_name())
     except ValidateException, ex:
         __logger.warning('WLSDPLY-06015', ex.getLocalizedMessage(), class_name=_class_name, method_name=_method_name)
 
 
-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 class_name: the class 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)
 
 
@@ -424,16 +449,17 @@ 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)
 
-    __check_and_customize_model(model, model_context)
+    __check_and_customize_model(model, model_context, aliases)
 
     try:
         __persist_model(model, model_context)

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

@@ -809,7 +809,7 @@ def get_model_attribute_name_and_value(self, location, wlst_attribute_name, wlst
         model_attribute_value = None
 
         attribute_info = self._alias_entries.get_alias_attribute_entry_by_wlst_name(location, wlst_attribute_name)
-        if attribute_info is not None:
+        if attribute_info is not None and not self.__is_model_attribute_read_only(location, attribute_info):
             data_type, delimiter = \
                 alias_utils.compute_read_data_type_and_delimiter_from_attribute_info(attribute_info,
                                                                                      wlst_attribute_value)

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

@@ -30,15 +30,14 @@ class CoherenceResourcesDiscoverer(Discoverer):
     Discover the weblogic coherence resources from the domain.
     """
 
-    def __init__(self, model_context, resource_dictionary, wlst_mode=WlstModes.OFFLINE,
-                 base_location=LocationContext()):
+    def __init__(self, model_context, resource_dictionary, base_location, wlst_mode=WlstModes.OFFLINE, aliases=None):
         """
         Initialize this discoverer instance with the specific information needed to discover coherence resources.
         :param model_context: context about the model for this instance of discover domain
         :param resource_dictionary: was provided on the discover call, else use initialized resources
         :param base_location: current context for discover or new context if not provided
         """
-        Discoverer.__init__(self, model_context, wlst_mode, base_location)
+        Discoverer.__init__(self, model_context, base_location, wlst_mode, aliases)
         self._dictionary = resource_dictionary
         self._add_att_handler(model_constants.COHERENCE_CUSTOM_CLUSTER_CONFIGURATION,
                               self._add_custom_configuration_to_archive)

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

@@ -30,15 +30,14 @@ class CommonResourcesDiscoverer(Discoverer):
     partition resource group.
     """
 
-    def __init__(self, model_context, resource_dictionary, wlst_mode=WlstModes.OFFLINE,
-                 base_location=LocationContext()):
+    def __init__(self, model_context, resource_dictionary, base_location, wlst_mode=WlstModes.OFFLINE, aliases=None):
         """
 
         :param model_context: context about the model for this instance of discover domain
         :param resource_dictionary: to populate the common resources. By default, populates the initialized resources
         :param base_location: to look for common weblogic resources. By default this is the global path or '/'
         """
-        Discoverer.__init__(self, model_context, wlst_mode, base_location)
+        Discoverer.__init__(self, model_context, base_location, wlst_mode, aliases)
         self._dictionary = resource_dictionary
         self._add_att_handler(model_constants.PATH_TO_SCRIPT, self._add_wldf_script)
 
@@ -59,10 +58,12 @@ def discover(self):
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
         model_folder_name, folder_result = self.get_jdbc_stores()
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
-        JmsResourcesDiscoverer(self._model_context, self._dictionary, wlst_mode=self._wlst_mode).discover()
+        JmsResourcesDiscoverer(self._model_context, self._dictionary, self._base_location, wlst_mode=self._wlst_mode,
+                               aliases=self._aliases).discover()
         model_folder_name, folder_result = self.get_wldf_system_resources()
         discoverer.add_to_model_if_not_empty(self._dictionary, model_folder_name, folder_result)
-        CoherenceResourcesDiscoverer(self._model_context, self._dictionary, wlst_mode=self._wlst_mode).discover()
+        CoherenceResourcesDiscoverer(self._model_context, self._dictionary, self._base_location,
+                                     wlst_mode=self._wlst_mode, aliases=self._aliases).discover()
 
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return self._dictionary

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

@@ -28,9 +28,8 @@ class DeploymentsDiscoverer(Discoverer):
     binaries and plans into the discovery archive file.
     """
 
-    def __init__(self, model_context, deployments_dictionary, wlst_mode=WlstModes.OFFLINE,
-                 base_location=LocationContext()):
-        Discoverer.__init__(self, model_context, wlst_mode, base_location)
+    def __init__(self, model_context, deployments_dictionary, base_location, wlst_mode=WlstModes.OFFLINE, aliases=None):
+        Discoverer.__init__(self, model_context, base_location, wlst_mode, aliases)
         self._dictionary = deployments_dictionary
 
     def discover(self):

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

@@ -32,7 +32,7 @@ class Discoverer(object):
     Discoverer contains the private methods used to facilitate discovery of the domain information by its subclasses.
     """
 
-    def __init__(self, model_context, wlst_mode, base_location=LocationContext()):
+    def __init__(self, model_context, base_location, wlst_mode, aliases=None):
         """
 
         :param model_context: context about the model for this instance of discover domain
@@ -41,8 +41,11 @@ def __init__(self, model_context, wlst_mode, base_location=LocationContext()):
         self._model_context = model_context
         self._base_location = base_location
         self._wlst_mode = wlst_mode
-        self.__aliases = Aliases(self._model_context, wlst_mode=self._wlst_mode)
-        self._alias_helper = AliasHelper(self.__aliases, _logger, ExceptionType.DISCOVER)
+        if aliases:
+            self._aliases = aliases
+        else:
+            self._aliases = Aliases(self._model_context, wlst_mode=self._wlst_mode)
+        self._alias_helper = AliasHelper(self._aliases, _logger, ExceptionType.DISCOVER)
         self._att_handler_map = OrderedDict()
         self._wls_version = WebLogicHelper(_logger).get_actual_weblogic_version()
         self._wlst_helper = WlstHelper(_logger, ExceptionType.DISCOVER)
@@ -61,10 +64,10 @@ def _populate_model_parameters(self, dictionary, location):
         wlst_path = self._alias_helper.get_wlst_attributes_path(location)
         _logger.finer('WLSDPLY-06100', wlst_path, class_name=_class_name, method_name=_method_name)
         self._wlst_helper.cd(wlst_path)
-        wlst_params = self._wlst_helper.lsa()
+        wlst_params = self._get_attributes_for_current_location(location)
         _logger.finest('WLSDPLY-06102', self._wlst_helper.get_pwd(), wlst_params, class_name=_class_name,
                        method_name=_method_name)
-        wlst_get_params = self._alias_helper.get_wlst_get_required_attribute_names(location)
+        wlst_get_params = self._get_required_attributes(location)
         _logger.finest('WLSDPLY-06103', str(location), wlst_get_params,
                        class_name=_class_name, method_name=_method_name)
         attr_dict = OrderedDict()
@@ -120,6 +123,50 @@ def _get_attributes_for_current_location(self, location):
                          method_name=_method_name)
         return attributes
 
+    def _get_required_attributes(self, location):
+        if self._wlst_mode == WlstModes.OFFLINE:
+            return self._get_required_attributes_offline(location)
+        else:
+            return self._get_required_attributes_online(location)
+
+    def _get_required_attributes_offline(self, location):
+        return self._alias_helper.get_wlst_get_required_attribute_names(location)
+
+    def _get_required_attributes_online(self, location):
+        """
+        Use get for all online attributes, and use the attribute names in the
+        :param location:
+        :return:
+        """
+        _method_name = '_get_required_attributes_online'
+        attributes = []
+        try:
+            mbi = wlst_helper.get_mbi()
+            mbean_attribute_info = mbi.getAttributes()
+            for mbean_attribute in mbean_attribute_info:
+                attributes.append(mbean_attribute.getName())
+        except PyWLSTException, pe:
+            name = location.get_model_folders()[-1]
+            _logger.warning('WLSDPLY-06109', name, str(location), pe.getLocalizedMessage(), class_name=_class_name,
+                            method_name=_method_name)
+        return attributes
+
+    def _mbean_names_exist(self, location):
+        """
+        Check to see if there are any configured MBeans for the current location
+        :param location: context with the current location
+        :return: True if MBeans of the type at the location exist
+        """
+        path = self._alias_helper.get_wlst_list_path(location)
+        mbean_name_map = None
+        try:
+            mbean_name_map = wlst_helper.lsa(path)
+        except DiscoverException, de:
+            _logger.warning('WLSDPLY-06130', path, de.getLocalizedMessage())
+        if mbean_name_map:
+            return True
+        return False
+
     def _check_attribute(self, model_name, model_value, location):
         """
         Check to see if the attribute has special handling indicated by the discover handler map. If the
@@ -203,10 +250,11 @@ def _discover_subfolder_singleton(self, model_subfolder_name, location):
         _logger.entering(model_subfolder_name, str(location), class_name=_class_name, method_name=_method_name)
         subfolder_result = OrderedDict()
         # For all server subfolder names there should only be one path
-        subfolder_path = self._alias_helper.get_wlst_attributes_path(location)
-        self._wlst_helper.cd(subfolder_path)
-        self._populate_model_parameters(subfolder_result, location)
-        self._discover_subfolders(subfolder_result, location)
+        if self._mbean_names_exist(location):
+            subfolder_path = self._alias_helper.get_wlst_attributes_path(location)
+            self._wlst_helper.cd(subfolder_path)
+            self._populate_model_parameters(subfolder_result, location)
+            self._discover_subfolders(subfolder_result, location)
         _logger.finest('WLSDPLY-06111', str(location), class_name=_class_name, method_name=_method_name)
         _logger.exiting(class_name=_class_name, method_name=_method_name)
         return subfolder_result

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

@@ -26,8 +26,8 @@ class DomainInfoDiscoverer(Discoverer):
     configuration files, but extra information that is required for the completeness of the domain.
     """
 
-    def __init__(self, model_context, domain_info_dictionary, wlst_mode=WlstModes.OFFLINE):
-        Discoverer.__init__(self, model_context, wlst_mode)
+    def __init__(self, model_context, domain_info_dictionary, base_location, wlst_mode=WlstModes.OFFLINE, aliases=None):
+        Discoverer.__init__(self, model_context, base_location, wlst_mode, aliases)
         self._dictionary = domain_info_dictionary
 
     def discover(self):

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

@@ -22,13 +22,13 @@ class GlobalResourcesDiscoverer(Discoverer):
 
     TYPE_domain = "Domain"
 
-    def __init__(self, model_context, resource_dictionary, wlst_mode=WlstModes.OFFLINE):
+    def __init__(self, model_context, resource_dictionary, base_location, wlst_mode=WlstModes.OFFLINE, aliases=None):
         """
 
         :param model_context: context about the model for this instance of the discover domain
         :param resource_dictionary: to populate with global resources. Uses the initialized resources if none passed
         """
-        Discoverer.__init__(self, model_context, wlst_mode)
+        Discoverer.__init__(self, model_context, base_location, wlst_mode, aliases)
         self._dictionary = resource_dictionary
 
     def discover(self):
@@ -58,7 +58,7 @@ def get_self_tuning(self):
         _logger.entering(class_name=_class_name, method_name=_method_name)
         result = OrderedDict()
         model_top_folder_name = model_constants.SELF_TUNING
-        location = LocationContext()
+        location = LocationContext(self._base_location)
         location.append_location(model_top_folder_name)
         tuning = self._find_singleton_name_in_folder(location)
         if tuning is not None:
@@ -77,7 +77,7 @@ def get_startup_classes(self):
         _logger.entering(class_name=_class_name, method_name=_method_name)
         result = OrderedDict()
         model_top_folder_name = model_constants.STARTUP_CLASS
-        location = LocationContext()
+        location = LocationContext(self._base_location)
         location.append_location(model_top_folder_name)
         startup_classes = self._find_names_in_folder(location)
         if startup_classes is not None:
@@ -102,7 +102,7 @@ def get_shutdown_classes(self):
         _logger.entering(class_name=_class_name, method_name=_method_name)
         result = OrderedDict()
         model_top_folder_name = model_constants.SHUTDOWN_CLASS
-        location = LocationContext()
+        location = LocationContext(self._base_location)
         location.append_location(model_top_folder_name)
         shutdown_classes = self._find_names_in_folder(location)
         if shutdown_classes is not None: