def get_partitions(self):
"""
Discover the partitions for the domain, including partition resources and resource groups.
:return: model name for the dictionary:dictionary containing the discovered partitions
"""
_method_name = 'get_partitions'
_logger.entering(class_name=_class_name, method_name=_method_name)
result = OrderedDict()
model_top_folder_name = model_constants.PARTITION
location = LocationContext(self._base_location)
location.append_location(model_top_folder_name)
partitions = self._find_names_in_folder(location)
if partitions is not None:
_logger.info('WLSDPLY-06705', len(partitions), class_name=_class_name, method_name=_method_name)
name_token = self._alias_helper.get_name_token(location)
for partition in partitions:
_logger.info('WLSDPLY-06706', partition, class_name=_class_name, method_name=_method_name)
location.add_name_token(name_token, partition)
result[partition] = self._discover_single_folder(location)
model_rg_name, rg_result = self.get_resource_groups(location)
discoverer.add_to_model_if_not_empty(result[partition], model_rg_name, rg_result)
wlst_subfolders = self._find_subfolders(location)
if wlst_subfolders is not None:
for wlst_subfolder in wlst_subfolders:
model_subfolder_name = self._get_model_name(location, wlst_subfolder)
if model_subfolder_name and not model_subfolder_name == model_constants.RESOURCE_GROUP:
self._discover_subfolder(model_subfolder_name, location, result[partition])
location.remove_name_token(name_token)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
return model_top_folder_name, result
def get_jms_system_resources(self):
"""
Discover the JMS system resources, including the sub-deployments, system resource attributes and all
the entities contained within a system resource from the domain.
:return: model folder name: dictionary with the discovered JMS system resources
"""
_method_name = 'get_jms_system_resources'
_logger.entering(class_name=_class_name, method_name=_method_name)
result = OrderedDict()
model_top_folder_name = model_constants.JMS_SYSTEM_RESOURCE
location = LocationContext(self._base_location)
location.append_location(model_top_folder_name)
jms_resources = self._find_names_in_folder(location)
if jms_resources is not None:
_logger.info('WLSDPLY-06478', len(jms_resources), class_name=_class_name, method_name=_method_name)
typedef = self._model_context.get_domain_typedef()
name_token = self._aliases.get_name_token(location)
for jms_resource in jms_resources:
if typedef.is_system_jms(jms_resource):
_logger.info('WLSDPLY-06491', typedef.get_domain_type(), jms_resource, class_name=_class_name,
method_name=_method_name)
else:
_logger.info('WLSDPLY-06479', jms_resource, class_name=_class_name, method_name=_method_name)
result[jms_resource] = OrderedDict()
location.add_name_token(name_token, jms_resource)
self._populate_model_parameters(result[jms_resource], location)
model_subfolder_name, subfolder_result = self._get_subdeployments(location)
discoverer.add_to_model_if_not_empty(result[jms_resource], model_subfolder_name, subfolder_result)
model_subfolder_name, subfolder_result = self._get_jms_resources(location)
discoverer.add_to_model_if_not_empty(result[jms_resource], model_subfolder_name, subfolder_result)
location.remove_name_token(name_token)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
return model_top_folder_name, result
def discover(self):
"""
Discover weblogic resources from the on-premise domain.
:return: resources dictionary created or updated during the jms discover
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.fine('WLSDPLY-06460',
class_name=_class_name,
method_name=_method_name)
model_folder_name, jms_servers = self.get_jms_servers()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, jms_servers)
model_folder_name, saf_agents = self.get_saf_agents()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, saf_agents)
model_folder_name, jms_resources = self.get_jms_system_resources()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, jms_resources)
model_folder_name, bridge_destinations = self.get_jms_bridge_destinations(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name,
bridge_destinations)
model_folder_name, bridges = self.get_jms_bridges()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, bridges)
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=self._dictionary)
return self._dictionary
def get_coherence_clusters(self):
"""
Discover the Coherence clusters and archive the necessary coherence artifacts.
:return: model folder name: dictionary with the discovered coherence clusters
"""
_method_name = '_get_coherence_clusters'
_logger.entering(class_name=_class_name, method_name=_method_name)
result = OrderedDict()
model_top_folder_name = model_constants.COHERENCE_CLUSTER_SYSTEM_RESOURCE
location = LocationContext(self._base_location)
location.append_location(model_top_folder_name)
coherence_clusters = self._find_names_in_folder(location)
if coherence_clusters is not None:
_logger.info('WLSDPLY-06311', len(coherence_clusters), class_name=_class_name, method_name=_method_name)
typedef = self._model_context.get_domain_typedef()
name_token = self._aliases.get_name_token(location)
for coherence_cluster in coherence_clusters:
if typedef.is_system_coherence_cluster(coherence_cluster):
_logger.info('WLSDPLY-06322', typedef.get_domain_type(), coherence_cluster, class_name=_class_name,
method_name=_method_name)
else:
_logger.info('WLSDPLY-06312', coherence_cluster, class_name=_class_name, method_name=_method_name)
location.add_name_token(name_token, coherence_cluster)
result[coherence_cluster] = OrderedDict()
self._populate_model_parameters(result[coherence_cluster], location)
model_subfolder_name, subfolder_result = self.get_coherence_cache_config(location)
discoverer.add_to_model_if_not_empty(result[coherence_cluster], model_subfolder_name,
subfolder_result)
model_subfolder_name, subfolder_result = self.get_coherence_resource(location)
discoverer.add_to_model_if_not_empty(result[coherence_cluster], model_subfolder_name,
subfolder_result)
location.remove_name_token(name_token)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
return model_top_folder_name, result
def discover(self):
"""
Discover weblogic global resources from the domain.
:return: resources: dictionary containing the discovered global resources
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.finer('WLSDPLY-06440',
class_name=_class_name,
method_name=_method_name)
model_top_folder_name, self_tuning = self.get_self_tuning()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
self_tuning)
model_top_folder_name, startups = self.get_startup_classes()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, startups)
model_top_folder_name, shutdowns = self.get_shutdown_classes()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, shutdowns)
model_top_folder_name, web_app_container = self.get_webapp_container()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
web_app_container)
model_top_folder_name, singleton_services = self.get_singleton_service(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
singleton_services)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def discover_domain_parameters(self):
"""
Discover the domain attributes and non-resource domain subfolders.
"""
_method_name = 'discover_domain_parameters'
_logger.entering(class_name=_class_name, method_name=_method_name)
location = LocationContext(self._base_location)
self._populate_model_parameters(self._dictionary, location)
model_folder_name, folder_result = self._get_jta()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_jmx()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_restful_management_services(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_domain_log()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_nm_properties()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
def _get_jms_resources(self, location):
_method_name = '_get_jms_resources'
_logger.entering(class_name=_class_name, method_name=_method_name)
result = OrderedDict()
model_name = model_constants.JMS_RESOURCE
location.append_location(model_name)
self._populate_model_parameters(result, location)
wlst_subfolders = self._find_subfolders(location)
if wlst_subfolders is not None:
for wlst_subfolder in wlst_subfolders:
model_subfolder_name = self._get_model_name(
location, wlst_subfolder)
if model_subfolder_name:
if model_subfolder_name == model_constants.TEMPLATE:
model_subfolder_name, subfolder_result = self._get_jms_templates(
location)
discoverer.add_to_model_if_not_empty(
result, model_subfolder_name, subfolder_result)
elif model_subfolder_name == model_constants.FOREIGN_SERVER:
model_subfolder_name, subfolder_result = self._get_foreign_servers(
location)
discoverer.add_to_model_if_not_empty(
result, model_subfolder_name, subfolder_result)
else:
self._discover_subfolder(model_subfolder_name,
location, result)
location.pop_location()
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=result)
return model_name, result
def _get_foreign_servers(self, location):
"""
Discover the foreign servers for the JMS resource from the domain.
:param location: context containing the current location information
:return: model folder name: dictionary containing the discovered foreign servers for the JMS resource
"""
_method_name = 'get_foreign_servers'
_logger.entering(str(location), class_name=_class_name, method_name=_method_name)
result = OrderedDict()
model_top_folder_name = model_constants.FOREIGN_SERVER
location.append_location(model_top_folder_name)
servers = self._find_names_in_folder(location)
if servers is not None:
name_token = self._alias_helper.get_name_token(location)
for server in servers:
_logger.finer('WLSDPLY-06480', server, self._alias_helper.get_model_folder_path(location),
class_name=_class_name, method_name=_method_name)
result[server] = OrderedDict()
location.add_name_token(name_token, server)
self._populate_model_parameters(result[server], location)
wlst_subfolders = self._find_subfolders(location)
if wlst_subfolders is not None:
for wlst_subfolder in wlst_subfolders:
model_subfolder_name = self._get_model_name(location, wlst_subfolder)
if model_subfolder_name and model_subfolder_name == model_constants.JNDI_PROPERTY:
model_subfolder_name, subfolder_result = self._get_foreign_server_properties(location)
discoverer.add_to_model_if_not_empty(result[server], model_subfolder_name, subfolder_result)
else:
self._discover_subfolder(model_subfolder_name, location, result[server])
location.remove_name_token(name_token)
location.pop_location()
_logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
return model_top_folder_name, result
def discover(self):
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06707',
class_name=_class_name,
method_name=_method_name)
model_top_folder_name, result = self.get_resource_management()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def discover(self):
"""
Discover the entities that make up the topology for partitions in the domain.
:return: dictionary containing discovered multi-tenant topology
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06709', class_name=_class_name, method_name=_method_name)
model_top_folder_name, result = self._get_virtual_targets()
discoverer.add_to_model_if_not_empty(self._dictionary, model_top_folder_name, result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def _get_jms_templates(self, location):
"""
Discover the JMS templates for the JMS resource from the domain.
:param location: context containing the current location information
:return: model folder name: dictionary containing the discovered JMS template
"""
_method_name = 'get_jms_templates'
_logger.entering(str(location),
class_name=_class_name,
method_name=_method_name)
result = OrderedDict()
model_top_folder_name = model_constants.TEMPLATE
location.append_location(model_top_folder_name)
templates = self._find_names_in_folder(location)
if templates is not None:
name_token = self._alias_helper.get_name_token(location)
for template in templates:
_logger.finer(
'WLSDPLY-06481',
template,
self._alias_helper.get_model_folder_path(location),
class_name=_class_name,
method_name=_method_name)
result[template] = OrderedDict()
location.add_name_token(name_token, template)
self._populate_model_parameters(result[template], location)
wlst_subfolders = self._find_subfolders(location)
if wlst_subfolders is not None:
for wlst_subfolder in wlst_subfolders:
model_subfolder_name = self._alias_helper.get_model_subfolder_name(
location, wlst_subfolder)
_logger.finer('WLSDPLY-06485',
model_subfolder_name,
template,
class_name=_class_name,
method_name=_method_name)
if model_subfolder_name == model_constants.GROUP_PARAMS:
model_subfolder_name, subfolder_result = self._get_group_params(
location)
discoverer.add_to_model_if_not_empty(
result[template], model_subfolder_name,
subfolder_result)
else:
self._discover_subfolder(model_subfolder_name,
location,
result[template])
location.remove_name_token(name_token)
location.pop_location()
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=result)
return model_top_folder_name, result
def discover(self):
"""
Discover the domain extra info resources. This information goes into a section of the model
that does not contain the WLST mbean information that describes the weblogic domain.
:return: dictionary containing the domain extra info
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
model_top_folder_name, result = self.get_domain_libs()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def discover(self):
"""
discover the global, resource group template and partition coherence resources.
:return: model name for coherence cluster:resources dictionary containing discovered coherence clusters
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.fine('WLSDPLY-06310', class_name=_class_name, method_name=_method_name)
model_top_folder_name, result = self.get_coherence_clusters()
discoverer.add_to_model_if_not_empty(self._dictionary, model_top_folder_name, result)
_logger.exiting(class_name=_class_name, method_name=_method_name, result=model_top_folder_name)
return model_top_folder_name, self._dictionary
def discover(self):
"""
Discover the deployment information from the domain. This is the API method to discover all
deployment information from the domain.
:return: dictionary containing the deployment information
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06380', class_name=_class_name, method_name=_method_name)
model_top_folder_name, libraries = self.get_shared_libraries()
discoverer.add_to_model_if_not_empty(self._dictionary, model_top_folder_name, libraries)
model_top_folder_name, applications = self.get_applications()
discoverer.add_to_model_if_not_empty(self._dictionary, model_top_folder_name, applications)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def discover(self):
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06700',
class_name=_class_name,
method_name=_method_name)
MultiTenantTopologyDiscoverer(self._model_context,
self._model.get_model_topology(),
self._base_location,
wlst_mode=self._wlst_mode,
aliases=self._aliases).discover()
MultiTenantResourcesDiscoverer(self._model_context,
self._model.get_model_resources(),
self._base_location,
wlst_mode=self._wlst_mode,
aliases=self._aliases).discover()
dictionary = self._model.get_model_resources()
model_folder_name, result = self.get_resource_group_templates()
discoverer.add_to_model_if_not_empty(dictionary, model_folder_name,
result)
model_folder_name, result = self.get_resource_groups(
self._base_location)
discoverer.add_to_model_if_not_empty(dictionary, model_folder_name,
result)
model_folder_name, result = self.get_partitions()
discoverer.add_to_model_if_not_empty(dictionary, model_folder_name,
result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._model.get_model()
def discover(self):
"""
Discover weblogic resources from the on-premise domain.
:return: resources: dictionary where to populate discovered domain resources
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
model_folder_name, folder_result = self.get_datasources()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.get_foreign_jndi_providers()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.get_mail_sessions()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.get_file_stores()
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)
model_folder_name, folder_result = self.get_path_services()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
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,
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
def discover_domain_parameters(self):
"""
Discover the domain attributes and non-resource domain subfolders.
"""
_method_name = 'discover_domain_parameters'
_logger.entering(class_name=_class_name, method_name=_method_name)
domain_home = '/'
location = LocationContext(self._base_location)
# This is temporary until a do not ignore is created for DomainName
success, wlst_value = self._get_attribute_value_with_get(
model_constants.DOMAIN_NAME, domain_home)
if success and wlst_value:
self._dictionary[model_constants.DOMAIN_NAME] = wlst_value
self._populate_model_parameters(self._dictionary, location)
model_folder_name, folder_result = self._get_admin_console()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_jta()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_jmx()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_restful_management_services(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_log_filters()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_reliable_delivery_policies(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_xml_entity_caches()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_xml_registries()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_domain_log()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_nm_properties()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
def discover(self):
"""
Discover the clusters, servers and machines that describe the domain's topology and return
the resulting topology data dictionary. Add any pertinent libraries referenced by a server's
start classpath to the archive file.
:return: topology data dictionary
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06600',
class_name=_class_name,
method_name=_method_name)
self.discover_domain_parameters()
model_top_folder_name, clusters = self.get_clusters()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, clusters)
model_top_folder_name, servers = self.get_servers()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, servers)
model_top_folder_name, migratable_targets = self.get_migratable_targets(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
migratable_targets)
model_top_folder_name, templates = self.get_server_templates()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, templates)
model_top_folder_name, unix_machines = self.get_unix_machines()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
unix_machines)
model_top_folder_name, machines = self.get_machines(unix_machines)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, machines)
model_top_folder_name, security_configuration = self.discover_security_configuration(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
security_configuration)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
def discover_domain_parameters(self):
"""
Discover the domain attributes and non-resource domain subfolders.
"""
_method_name = 'discover_domain_parameters'
_logger.entering(class_name=_class_name, method_name=_method_name)
domain_home = '/'
location = LocationContext(self._base_location)
# This is temporary until a do not ignore is created for DomainName
success, wlst_value = self._get_attribute_value_with_get(
model_constants.DOMAIN_NAME, domain_home)
if success and wlst_value:
self._dictionary[model_constants.DOMAIN_NAME] = wlst_value
self._populate_model_parameters(self._dictionary, location)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.ADMIN_CONSOLE)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.CDI_CONTAINER)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.JMX)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.JPA)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.JTA)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.LOG)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_nm_properties()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self.discover_domain_mbean(
model_constants.RESTFUL_MANAGEMENT_SERVICES)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
def discover(self):
"""
Discover the clusters, servers and machines that describe the domain's topology and return
the resulting topology data dictionary. Add any pertinent libraries referenced by a server's
start classpath to the archive file.
:return: topology data dictionary
"""
_method_name = 'discover'
_logger.entering(class_name=_class_name, method_name=_method_name)
_logger.info('WLSDPLY-06600',
class_name=_class_name,
method_name=_method_name)
self.discover_domain_parameters()
model_top_folder_name, clusters = self.get_clusters()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, clusters)
model_top_folder_name, servers = self.get_servers()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, servers)
model_top_folder_name, migratable_targets = self.get_migratable_targets(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
migratable_targets)
model_top_folder_name, templates = self.get_server_templates()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, templates)
model_top_folder_name, unix_machines = self.get_unix_machines()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
unix_machines)
model_top_folder_name, machines = self.get_machines(unix_machines)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name, machines)
# make sure this is after discovery of machines / node managers as we will do some massaging
model_top_folder_name, security_configuration = self.discover_security_configuration(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
security_configuration)
model_top_folder_name, embedded_ldap_configuration = self.get_embedded_ldap_configuration(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_top_folder_name,
embedded_ldap_configuration)
model_folder_name, folder_result = self._get_log_filters()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_reliable_delivery_policies(
)
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_xml_entity_caches()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
model_folder_name, folder_result = self._get_xml_registries()
discoverer.add_to_model_if_not_empty(self._dictionary,
model_folder_name, folder_result)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return self._dictionary
