Wdt 228 target dynamic servers to cluster

core/src/main/java/oracle/weblogic/deploy/util/StringUtils.java

@@ -147,4 +147,20 @@ public static String[] splitCommaSeparatedList(String listString) {
  return listString.split(COMMA_SEPARATED_LIST_SPLITTER);
  }
 
+ /**
+ * Return a printable string representing the Boolean True or False value for the integer.
+ * @param value containing the integer value of a boolean
+ * @return String representation of the boolean integer
+ */
+ public static String stringForBoolean(int value) {
+ switch(value) {
+ case 0:
+ return Boolean.FALSE.toString();
+ case 1:
+ return Boolean.TRUE.toString();
+ default:
+ return "UNKNOWN";
+ }
+ }
+
 }

core/src/main/python/wlsdeploy/tool/create/creator.py

@@ -10,15 +10,15 @@
 from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.logging.platform_logger import PlatformLogger
-from wlsdeploy.tool.deploy import deployer_utils
+from wlsdeploy.util import dictionary_utils
 from wlsdeploy.tool.util.alias_helper import AliasHelper
 from wlsdeploy.tool.util.attribute_setter import AttributeSetter
 from wlsdeploy.tool.util.custom_folder_helper import CustomFolderHelper
 from wlsdeploy.tool.util.wlst_helper import WlstHelper
-from wlsdeploy.util import dictionary_utils
 from wlsdeploy.util.model import Model
 from wlsdeploy.util.weblogic_helper import WebLogicHelper
-
+from wlsdeploy.tool.deploy import deployer_utils
+
 
 class Creator(object):
  """

core/src/main/python/wlsdeploy/tool/create/domain_creator.py

@@ -4,7 +4,6 @@
 """
 import javaos as os
 from oracle.weblogic.deploy.create import RCURunner
-
 from wlsdeploy.aliases.location_context import LocationContext
 from wlsdeploy.aliases.model_constants import ADMIN_PASSWORD
 from wlsdeploy.aliases.model_constants import ADMIN_SERVER_NAME
@@ -415,8 +414,6 @@ def __extend_domain(self, domain_home):
  self.target_helper.target_server_groups_to_servers(server_groups_to_target)
  self.wlst_helper.update_domain()
  elif self._domain_typedef.is_jrf_domain_type():
- # Update the domain to apply the extension templates.
- self.wlst_helper.update_domain()
  self.target_helper.target_jrf_groups_to_clusters_servers(domain_home)
 
  self.wlst_helper.close_domain()
@@ -457,13 +454,20 @@ def __create_domain_with_select_template(self, domain_home):
  self.__set_app_dir()
  self.__configure_fmw_infra_database()
 
- server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
- self.target_helper.target_server_groups_to_servers(server_groups_to_target)
-
  self.logger.info('WLSDPLY-12206', self._domain_name, domain_home,
  class_name=self.__class_name, method_name=_method_name)
+
+ server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
+ server_assigns, dynamic_assigns = self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+ if server_assigns is not None:
+ self.target_helper.target_server_groups(server_assigns)
+
  self.wlst_helper.write_domain(domain_home)
  self.wlst_helper.close_template()
+
+ if dynamic_assigns is not None:
+ self.target_helper.target_server_groups_to_dynamic_clusters(dynamic_assigns)
+
  self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
  return
 

core/src/main/python/wlsdeploy/tool/create/domain_typedef.py

@@ -29,6 +29,7 @@ class DomainTypedef(object):
  __domain_typedef_extension = '.json'
 
  JRF_TEMPLATE_REGEX = "^(.*jrf_template[0-9._]*\\.jar)|(Oracle JRF WebServices Asynchronous services)$"
+ RESTRICTED_JRF_TEMPLATE_REGEX = "^(Oracle Restricted JRF)$"
 
  def __init__(self, program_name, domain_type):
  """
@@ -94,6 +95,13 @@ def get_domain_type(self):
  """
  return self._domain_type
 
+ def has_jrf_resources(self):
+ """
+ Determine if the domain type has domain resources from either the JRF or Restricted JRF templates.
+ :return: True if the domain type has resources from one of the JRF type
+ """
+ return self.is_jrf_domain_type() or self.is_restricted_jrf_domain_type()
+
  def is_jrf_domain_type(self):
  """
  Determine if this is a JRF domain type by checking for the JRF extension template.
@@ -105,12 +113,15 @@ def is_jrf_domain_type(self):
  return True
  return False
 
- def domain_type_has_jrf_resources(self):
+ def is_restricted_jrf_domain_type(self):
  """
- Does the running domain type contain the JRF server group ?
- :return:
+ Determine if this domain type applies the Restricted JRF template.
+ :return: True if the Restricted JRF template is in the extension templates list
  """
- return 'JRF-MAN-SVR' in self.get_server_groups_to_target()
+ for template in self.get_extension_templates():
+ if re.match(self.RESTRICTED_JRF_TEMPLATE_REGEX, template):
+ return True
+ return False
 
  def get_base_template(self):
  """
@@ -121,6 +132,14 @@ def get_base_template(self):
  self.__resolve_paths()
  return self._domain_typedef['baseTemplate']
 
+ def has_extension_templates(self):
+ """
+ Determine if the domain type has extension templates.
+ :return: True if the domain type will apply extension templates
+ """
+ ets = self.get_extension_templates()
+ return ets is not None and len(ets) > 0
+
  def get_extension_templates(self):
  """
  Get the list of extension templates to apply when create/extending the domain.

core/src/main/python/wlsdeploy/tool/deploy/deployer_utils.py

@@ -279,44 +279,3 @@ def get_file_hash(file_name):
  raise ex
  _logger.exiting(class_name=_class_name, method_name=_method_name, result=result)
  return result
-
-
-def save_changes(model_context):
- """
- Call this if necessary to save changes and disconnect from the domain.
- This works in both offline and online.
- :param model_context: contains information about the current tool settings
- """
- _method_name = 'save_changes'
- if model_context.get_target_wlst_mode() == WlstModes.ONLINE:
- if _wlst_helper.is_connected():
- _logger.fine('WLSDPLY-09110', class_name=_class_name, method_name=_method_name)
- _wlst_helper.save()
- _wlst_helper.activate()
- _wlst_helper.disconnect()
- else:
- _logger.fine('WLSDPLY-09109', class_name=_class_name, method_name=_method_name)
- else:
- _logger.fine('WLSDPLY-09111', class_name=_class_name, method_name=_method_name)
- _wlst_helper.update_domain()
-
-
-def read_again(model_context):
- """
- Establish connection with the domain and start editing in both online and offline wlst mode.
- :param model_context: contains information about the current tool settings
- """
- _method_name = 'read_again'
- if model_context.get_target_wlst_mode() == WlstModes.ONLINE:
- if not _wlst_helper.is_connected():
- _logger.fine('WLSDPLY-09113', class_name=_class_name, method_name=_method_name)
- _wlst_helper.connect(model_context.get_admin_user(), model_context.get_admin_password(),
- model_context.get_admin_url())
- _wlst_helper.edit()
- _wlst_helper.start_edit()
- else:
- _logger.fine('WLSDPLY-09112', class_name=_class_name, method_name=_method_name)
- else:
- _logger.fine('WLSDPLY-09114', class_name=_class_name, method_name=_method_name)
- _wlst_helper.close_domain()
- _wlst_helper.read_domain(model_context.get_domain_home())

core/src/main/python/wlsdeploy/tool/deploy/topology_updater.py

@@ -14,6 +14,7 @@
 from wlsdeploy.aliases.model_constants import SERVER_TEMPLATE
 from wlsdeploy.aliases.model_constants import UNIX_MACHINE
 from wlsdeploy.aliases.wlst_modes import WlstModes
+from wlsdeploy.exception import exception_helper
 from wlsdeploy.exception.expection_types import ExceptionType
 from wlsdeploy.tool.create.security_provider_creator import SecurityProviderCreator
 from wlsdeploy.tool.deploy import deployer_utils
@@ -34,16 +35,17 @@ def __init__(self, model, model_context, aliases, wlst_mode=WlstModes.OFFLINE):
  Deployer.__init__(self, model, model_context, aliases, wlst_mode)
  self._topology = self.model.get_model_topology()
  self._resources = self.model.get_model_resources()
- self._topology_helper = TopologyHelper(self.aliases, ExceptionType.DEPLOY, self.logger)
+ self._exception_type = ExceptionType.DEPLOY
+ self._topology_helper = TopologyHelper(self.aliases, self._exception_type, self.logger)
  self._domain_typedef = self.model_context.get_domain_typedef()
 
  self._security_provider_creator = SecurityProviderCreator(model.get_model(), model_context, aliases,
- ExceptionType.DEPLOY, self.logger)
+ self._exception_type, self.logger)
 
  self.library_helper = LibraryHelper(self.model, self.model_context, self.aliases,
- model_context.get_domain_home(), ExceptionType.DEPLOY, self.logger)
+ model_context.get_domain_home(), self._exception_type, self.logger)
 
- self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, ExceptionType.DEPLOY,
+ self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, self._exception_type,
  self.logger)
 
  # Override
@@ -72,7 +74,11 @@ def update(self):
  """
  Deploy resource model elements at the domain level, including multi-tenant elements.
  """
+ # For issue in setServerGroups in online mode (new configured clusters and stand-alone managed servers
+ # will not have extension template resources targeted)
+ existing_managed_servers, existing_configured_clusters = self._create_list_of_setservergroups_targets()
  domain_token = deployer_utils.get_domain_token(self.alias_helper)
+
  location = LocationContext()
  location.add_name_token(domain_token, self.model_context.get_domain_name())
 
@@ -104,24 +110,33 @@ def update(self):
  # create placeholders for Servers that are in a cluster as /Server/JTAMigratableTarget
  # can reference "other" servers
  self._topology_helper.create_placeholder_servers_in_cluster(self._topology)
+
  self._process_section(self._topology, folder_list, SERVER, location)
 
  self._process_section(self._topology, folder_list, MIGRATABLE_TARGET, location)
 
+ new_managed_server_list, new_configured_cluster_list = self._create_list_of_setservergroups_targets()
+
+ self._check_for_online_setservergroups_issue(existing_managed_servers, new_managed_server_list)
+ self._check_for_online_setservergroups_issue(existing_configured_clusters, new_configured_cluster_list)
+
  # process remaining top-level folders. copy list to avoid concurrent update in loop
  remaining = list(folder_list)
  for folder_name in remaining:
  self._process_section(self._topology, folder_list, folder_name, location)
 
  if self.wls_helper.is_set_server_groups_supported():
  server_groups_to_target = self._domain_typedef.get_server_groups_to_target()
- self.target_helper.target_server_groups_to_servers(server_groups_to_target)
- elif self._domain_typedef.domain_type_has_jrf_resources():
- deployer_utils.save_changes(self.model_context)
- self.target_helper.target_jrf_groups_to_clusters_servers(self.model_context.get_domain_home())
- deployer_utils.read_again(self.model_context)
-
- # files referenced in attributes are extracted as attributes are processed
+ server_assigns, dynamic_assigns = \
+ self.target_helper.target_server_groups_to_servers(server_groups_to_target)
+ if dynamic_assigns is not None:
+ self.wlst_helper.save_and_close(self.model_context)
+ self.target_helper.target_server_groups_to_dynamic_clusters(dynamic_assigns)
+ self.wlst_helper.reopen(self.model_context)
+ if server_assigns is not None:
+ self.target_helper.target_server_groups(server_assigns)
+ elif self._domain_typedef.is_jrf_domain_type():
+ self.target_helper.target_jrf_groups_to_clusters_servers()
 
  self.library_helper.install_domain_libraries()
  self.library_helper.extract_classpath_libraries()
@@ -153,3 +168,67 @@ def _set_domain_attributes(self):
  attribute_path = self.alias_helper.get_wlst_attributes_path(location)
  self.wlst_helper.cd(attribute_path)
  self.set_attributes(location, attrib_dict)
+
+ def is_online_with_ext_templates(self):
+ return self.model_context.is_wlst_online() and self.model_context.get_domain_typedef().has_extension_templates()
+
+ def _check_for_online_setservergroups_issue(self, existing_list, new_list):
+ _method_name = '_check_for_online_setservergroups_issue'
+ if len(existing_list) != len(new_list):
+ for entity_name in new_list:
+ if entity_name not in existing_list:
+ self.logger.warning('WLSDPLY-09701', entity_name,
+ class_name=self._class_name, method_name=_method_name)
+ return
+
+ def _create_list_of_setservergroups_targets(self):
+ """
+ If an update is executed in online WLST mode, return a list of all existing configured / mixed clusters and
+ stand-alone managed servers. This method will be invoked to create a list of existing, and a list of new
+ as added by the update tool. These lists will be compared to determine if they will encounter
+ the online WLST problem with setServerGroups. The setServerGroups will target template resources to the
+ new entities, but this targeting is not persisted to the config.xml.
+ """
+ _method_name = '_create_list_of_setservergroups_targets'
+ self.logger.entering(class_name=self._class_name, method_name=_method_name)
+
+ if not self.is_online_with_ext_templates():
+ self.logger.exiting(class_name=self._class_name, method_name=_method_name)
+ return list(), list()
+
+ location = LocationContext().append_location(SERVER)
+ server_path = self.alias_helper.get_wlst_list_path(location)
+ existing_managed_servers = list()
+ existing_servers = self.wlst_helper.get_existing_object_list(server_path)
+ if existing_servers is not None:
+ name_token = self.alias_helper.get_name_token(location)
+ for server_name in existing_servers:
+ location.add_name_token(name_token, server_name)
+ wlst_path = self.alias_helper.get_wlst_attributes_path(location)
+ self.wlst_helper.cd(wlst_path)
+ cluster_attribute = self.alias_helper.get_wlst_attribute_name(location, CLUSTER)
+ cluster_value = self.wlst_helper.get(cluster_attribute)
+ if cluster_value is None:
+ existing_managed_servers.append(server_name)
+ location.remove_name_token(name_token)
+
+ existing_configured_clusters = list()
+ location = LocationContext().append_location(CLUSTER)
+ cluster_path = self.alias_helper.get_wlst_list_path(location)
+ existing_clusters = self.wlst_helper.get_existing_object_list(cluster_path)
+ if existing_clusters is not None:
+ name_token = self.alias_helper.get_name_token(location)
+ for cluster_name in existing_clusters:
+ location.add_name_token(name_token, cluster_name)
+ wlst_path = self.alias_helper.get_wlst_attributes_path(location)
+ self.wlst_helper.cd(wlst_path)
+ ds_mbean = self.alias_helper.get_wlst_mbean_type(location)
+ if not self.wlst_helper.subfolder_exists(ds_mbean,
+ self.alias_helper.get_wlst_subfolders_path(location)):
+ existing_configured_clusters.append(cluster_name)
+ location.remove_name_token(name_token)
+
+ self.logger.exiting(class_name=self._class_name, method_name=_method_name,
+ result='configured_clusters=' + str(existing_configured_clusters) +
+ ' managed servers=' + str(existing_managed_servers))
+ return existing_configured_clusters, existing_managed_servers

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

@@ -2,6 +2,10 @@
 Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
 The Universal Permissive License (UPL), Version 1.0
 """
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBeanImplBeanInfo
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBeanImpl
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorMBean
+from com.sun.identity.agents.weblogic.v10 import AgentAuthenticatorImpl
 from java.io import File
 from java.lang import IllegalArgumentException
 
@@ -46,6 +50,7 @@ def __init__(self, model_context, topology_dictionary, base_location, wlst_mode=
  self._add_att_handler(model_constants.CLASSPATH, self._add_classpath_libraries_to_archive)
  self._add_att_handler(model_constants.CUSTOM_IDENTITY_KEYSTORE_FILE, self._add_keystore_file_to_archive)
  self._add_att_handler(model_constants.CUSTOM_TRUST_KEYSTORE_FILE, self._add_keystore_file_to_archive)
+ self.agent_authenticator = AgentAuthenticatorImpl()
 
  def discover(self):
  """