Merge branch 'master' into WDT-221-add-jrf-installed-authentication-provider

Author: CarolynRountree

core/src/main/antlr4/oracle/weblogic/deploy/yaml/Yaml.g4

@@ -280,7 +280,7 @@ fragment ID_START
 fragment ID_CONTINUE
     : ID_START
     | [0-9]
-    | [. ()]
+    | [. ()/]
     ;
 
 // to support variables in IDs that will need to be quoted because of the curly braces
@@ -292,7 +292,7 @@ fragment QUOTED_ID_START
 
 fragment QUOTED_ID_CONTINUE
     : ID_CONTINUE
-    | [@#\-(){}[\]:]
+    | [@#\-(){}[\]:/]
     ;
 
 fragment SQUOTED_STRING_CHARS

core/src/main/python/discover.py

@@ -289,8 +289,9 @@ def __connect_to_domain(model_context):
         try:
             wlst_helper.read_domain(model_context.get_domain_home())
         except PyWLSTException, wlst_ex:
+            wls_version = WebLogicHelper(__logger).get_actual_weblogic_version()
             ex = exception_helper.create_discover_exception('WLSDPLY-06002', model_context.get_domain_home(),
-                                                            wlst_ex.getLocalizedMessage(), error=wlst_ex)
+                                                            wls_version, wlst_ex.getLocalizedMessage(), error=wlst_ex)
             __logger.throwing(ex, class_name=_class_name, method_name=_method_name)
             raise ex
 

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

@@ -18,14 +18,14 @@ class JVMArguments(object):
 
     _class_name = 'JVMArguments'
     __client_server_regex = re.compile('-client|-server')
-    __x_args_size_regex = re.compile('(-X(ms|mx|ss|mn) ?)([0-9]+[kmg]? ?)')
+    __x_args_size_regex = re.compile('(-X(ms|mx|ss|mn) ?)([0-9]+[kmgKMG]? ?)')
     __x_args_value_regex = re.compile('(-X[a-zS]+(/[ap])? ?):([\S]+ ?)')
-    __x_args_other_regex = re.compile('(-X[a-z]+ ?)(=([0-9]+[kmg]? ?))?')
+    __x_args_other_regex = re.compile('(-X[a-z]+ ?)(=([0-9]+[kmgKMG]? ?))?')
     __xx_args_switch_regex = re.compile('-XX:([+-] ?)([a-zA-Z0-9]+ ?)')
     __xx_args_value_regex = re.compile('-XX:([a-zA-Z0-9]+ ?)=([\S]+ ?)')
     __sys_props_regex = re.compile('-D([a-zA-Z0-9-_.]+ ?)(=([\S]+ ?))?')
 
-    __size_regex = re.compile('([0-9]+ ?)([kmg]? ?)')
+    __size_regex = re.compile('([0-9]+ ?)([kmgKMG]? ?)')
     __k_multiplier = 1024
     __m_multiplier = 1024 * 1024
     __g_multiplier = 1024 * 1024 * 1024
@@ -588,11 +588,11 @@ def __get_size_multiplier(self, multiplier):
         """
         if multiplier is None:
             result = 1
-        elif multiplier == 'k':
+        elif multiplier in ['k', 'K']:
             result = self.__k_multiplier
-        elif multiplier == 'm':
+        elif multiplier in ['m', 'M']:
             result = self.__m_multiplier
-        elif multiplier == 'g':
+        elif multiplier in ['g', 'G']:
             result = self.__g_multiplier
         else:
             result = 0

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

@@ -663,12 +663,12 @@ def get_number_of_directories_to_strip(desired_path_type, actual_path_type):
 
 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
+    Convert WLST value to model representation type
+    :param data_type: the target data type for the model
+    :param value: value to be converted
+    :param preferred: the preferred data type to be represented in the model (optional)
+    :param delimiter: the delimiter for parsing the WLST representation of the data value (optional)
+    :return: converted value
     """
 
     _method_name = 'convert_from_type'
@@ -835,6 +835,14 @@ def get_dictionary_mode(alias_dict):
 
 
 def _jconvert_to_type(data_type, value, delimiter):
+    """
+    Convert WLST value to model representation type.
+    Assumes that empty values and password data types have been converted elsewhere.
+    :param data_type: the target data type for the model
+    :param value: value to be converted
+    :param delimiter: the delimiter for parsing the WLST representation of the data value (optional)
+    :return: converted value
+    """
     _method_name = '_jconvert_to_type'
     try:
         converted = TypeUtils.convertToType(data_type, value, delimiter)

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

@@ -4,7 +4,6 @@
 """
 
 from oracle.weblogic.deploy.util import WLSDeployArchive
-from oracle.weblogic.deploy.exception import BundleAwareException
 
 from wlsdeploy.aliases.location_context import LocationContext
 from wlsdeploy.aliases.validation_codes import ValidationCodes
@@ -166,97 +165,56 @@ def _create_mbean(self, type_name, model_nodes, base_location, log_created=False
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
 
-    def _create_security_provider_mbeans(self, type_name, model_nodes, base_location, log_created=False):
+    def _create_named_subtype_mbeans(self, type_name, model_nodes, base_location, log_created=False):
         """
-        Create the specified security provider MBean types that support multiple instances but use an
-        artificial type subfolder in the specified location.
+        Create the specified type of MBeans that support multiple instances, and require an artificial subtype
+        layer after each name.
+        There is no default behavior for this method. Sub-classes (currently only SecurityProviderCreator) will
+        implement specialized behavior.
         :param type_name: the model folder type
         :param model_nodes: the model dictionary of the specified model folder type
         :param base_location: the base location object to use to create the MBeans
         :param log_created: whether or not to log created at INFO level, by default it is logged at the FINE level
         :raises: CreateException: if an error occurs
         """
-        _method_name = '_create_security_provider_mbeans'
-
-        self.logger.entering(type_name, str(base_location), log_created,
-                             class_name=self.__class_name, method_name=_method_name)
-        if not self._is_type_valid(base_location, type_name):
-            return
-
-        location = LocationContext(base_location).append_location(type_name)
-        self._process_flattened_folder(location)
-
-        # For create, delete the existing nodes, and re-add in order found in model in iterative code below
-        self._delete_existing_providers(location)
-
-        if model_nodes is None or len(model_nodes) == 0:
-            return
-
-        token_name = self.alias_helper.get_name_token(location)
-        create_path = self.alias_helper.get_wlst_create_path(location)
-        list_path = self.alias_helper.get_wlst_list_path(location)
-        existing_folder_names = self._get_existing_folders(list_path)
-        known_providers = self.alias_helper.get_model_subfolder_names(location)
-        allow_custom = str(self.alias_helper.is_custom_folder_allowed(location))
-
-        for model_name in model_nodes:
-            model_node = model_nodes[model_name]
-
-            if model_node is None:
-                # The node is empty so nothing to do... move to the next named node.
-                continue
-
-            if len(model_node) != 1:
-                # there should be exactly one type folder under the name folder
-                ex = exception_helper.create_exception(self._exception_type, 'WLSDPLY-12117', type_name, model_name,
-                                                       len(model_node))
-                self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
-                raise ex
-
-            model_type_subfolder_name = list(model_node.keys())[0]
-            child_nodes = dictionary_utils.get_dictionary_element(model_node, model_type_subfolder_name)
-
-            # custom providers require special processing, they are not described in alias framework
-            if allow_custom and (model_type_subfolder_name not in known_providers):
-                self.custom_folder_helper.update_security_folder(base_location, type_name, model_type_subfolder_name,
-                                                                 model_name, child_nodes)
-                continue
+        return
 
-            # for a known provider, process using aliases
-            prov_location = LocationContext(location)
-            name = self.wlst_helper.get_quoted_name_for_wlst(model_name)
-            if token_name is not None:
-                prov_location.add_name_token(token_name, name)
+    def _create_subfolders(self, location, model_nodes):
+        """
+        Create the child MBean folders at the specified location.
+        :param location: the location
+        :param model_nodes: the model dictionary
+        :raises: CreateException: if an error occurs
+        """
+        _method_name = '_create_subfolders'
 
-            wlst_base_provider_type, wlst_name = self.alias_helper.get_wlst_mbean_type_and_name(prov_location)
+        self.logger.entering(location.get_folder_path(), class_name=self.__class_name, method_name=_method_name)
+        model_subfolder_names = self.alias_helper.get_model_subfolder_names(location)
+        for key in model_nodes:
+            if key in model_subfolder_names:
+                subfolder_nodes = model_nodes[key]
+                # don't check for empty subfolder nodes here, some create methods allow them
 
-            prov_location.append_location(model_type_subfolder_name)
-            wlst_type = self.alias_helper.get_wlst_mbean_type(prov_location)
+                sub_location = LocationContext(location).append_location(key)
 
-            if wlst_name not in existing_folder_names:
-                if log_created:
-                    self.logger.info('WLSDPLY-12118', type_name, model_type_subfolder_name, name, create_path,
-                                     class_name=self.__class_name, method_name=_method_name)
-                else:
-                    self.logger.fine('WLSDPLY-12118', type_name, model_type_subfolder_name, name, create_path,
-                                     class_name=self.__class_name, method_name=_method_name)
-                self.wlst_helper.cd(create_path)
-                self.wlst_helper.create(wlst_name, wlst_type, wlst_base_provider_type)
-            else:
-                if log_created:
-                    self.logger.info('WLSDPLY-12119', type_name, model_type_subfolder_name, name, create_path,
-                                     class_name=self.__class_name, method_name=_method_name)
+                if self.alias_helper.requires_artificial_type_subfolder_handling(sub_location):
+                    self.logger.finest('WLSDPLY-12116', key, str(sub_location), subfolder_nodes,
+                                       class_name=self.__class_name, method_name=_method_name)
+                    self._create_named_subtype_mbeans(key, subfolder_nodes, location, True)
+                elif self.alias_helper.supports_multiple_mbean_instances(sub_location):
+                    self.logger.finest('WLSDPLY-12109', key, str(sub_location), subfolder_nodes,
+                                       class_name=self.__class_name, method_name=_method_name)
+                    self._create_named_mbeans(key, subfolder_nodes, location)
+                elif self.alias_helper.is_artificial_type_folder(sub_location):
+                    # these should have been handled inside create_named_subtype_mbeans
+                    ex = exception_helper.create_create_exception('WLSDPLY-12120', str(sub_location),
+                                                                  key, str(location))
+                    self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
+                    raise ex
                 else:
-                    self.logger.fine('WLSDPLY-12119', type_name, model_type_subfolder_name, name, create_path,
-                                     class_name=self.__class_name, method_name=_method_name)
-
-            attribute_path = self.alias_helper.get_wlst_attributes_path(prov_location)
-            self.wlst_helper.cd(attribute_path)
-
-            self.logger.finest('WLSDPLY-12111', self.alias_helper.get_model_folder_path(prov_location),
-                               self.wlst_helper.get_pwd(), class_name=self.__class_name, method_name=_method_name)
-            self._set_attributes(prov_location, child_nodes)
-            self._create_subfolders(prov_location, child_nodes)
+                    self.logger.finest('WLSDPLY-12110', key, str(sub_location), subfolder_nodes,
+                                       class_name=self.__class_name, method_name=_method_name)
+                    self._create_mbean(key, subfolder_nodes, location)
 
         self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
         return
@@ -382,44 +340,6 @@ def _set_attribute(self, location, model_name, model_value, uses_path_tokens_nam
             self.wlst_helper.set(wlst_name, wlst_value, masked=masked)
         return
 
-    def _create_subfolders(self, location, model_nodes):
-        """
-        Create the child MBean folders at the specified location.
-        :param location: the location
-        :param model_nodes: the model dictionary
-        :raises: CreateException: if an error occurs
-        """
-        _method_name = '_create_subfolders'
-
-        self.logger.entering(location.get_folder_path(), class_name=self.__class_name, method_name=_method_name)
-        model_subfolder_names = self.alias_helper.get_model_subfolder_names(location)
-        for key in model_nodes:
-            if key in model_subfolder_names:
-                subfolder_nodes = model_nodes[key]
-                sub_location = LocationContext(location).append_location(key)
-                # both create and update are merge to model so will process a subfolder with an empty node
-                if self.alias_helper.requires_artificial_type_subfolder_handling(sub_location):
-                    self.logger.finest('WLSDPLY-12116', key, str(sub_location), subfolder_nodes,
-                                       class_name=self.__class_name, method_name=_method_name)
-                    self._create_security_provider_mbeans(key, subfolder_nodes, location, True)
-                elif len(subfolder_nodes) != 0:
-                    if self.alias_helper.supports_multiple_mbean_instances(sub_location):
-                        self.logger.finest('WLSDPLY-12109', key, str(sub_location), subfolder_nodes,
-                                           class_name=self.__class_name, method_name=_method_name)
-                        self._create_named_mbeans(key, subfolder_nodes, location)
-                    elif self.alias_helper.is_artificial_type_folder(sub_location):
-                        ex = exception_helper.create_create_exception('WLSDPLY-12120', str(sub_location),
-                                                                      key, str(location))
-                        self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
-                        raise ex
-                    else:
-                        self.logger.finest('WLSDPLY-12110', key, str(sub_location), subfolder_nodes,
-                                           class_name=self.__class_name, method_name=_method_name)
-                        self._create_mbean(key, subfolder_nodes, location)
-
-        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
-        return
-
     def _is_type_valid(self, location, type_name):
         """
         Verify that the specified location in valid for the current WLS version.
@@ -457,62 +377,6 @@ def _process_flattened_folder(self, location):
                 self.wlst_helper.create(mbean_name, mbean_type)
         return
 
-    def _delete_existing_providers(self, location):
-        """
-        The security realms providers in the model are processed as merge to the model. Each realm provider
-        section must be complete and true to the resulting domain. Any existing provider not found in the
-        model will be removed, and any provider in the model but not in the domain will be added. The resulting
-        provider list will be ordered as listed in the model. If the provider type (i.e. AuthenticationProvider)
-        is not in the model, it is assumed no configuration or ordering is needed, and the provider is skipped.
-        If the provider type is in the model, but there is no MBean entry under the provider, then it is 
-        assumed that all providers for that provider type must be removed.
-
-        For create, the default realm and default providers have been added by the weblogic base template and any
-        extension templates. They have default values. These providers will be removed from the domain. During
-        the normal iteration through the provider list, the providers, if in the model, will be re-added in model
-        order. Any attributes in the model that are not the default value are then applied to the the new provider.
-
-        By deleting all providers and re-adding from the model, we are both merging to the model and ordering the
-        providers. In offline wlst, the set<providertype>Providers(<provider_object_list>, which reorders existing
-        providers, does not work. Deleting the providers and re-adding also has the added benefit of fixing the 11g
-        problem where the providers have no name. They are returned with the name 'Provider'. In the authentication
-        provider, there are two default providers, and just setting the name does not work. When we re-add we re-add
-        with the correct name. And the DefaultAuthenticationProvider successfully re-adds with the correct default
-        identity asserter.
-
-        This release also supports updating the security configuration realms in both offline and online mode. This
-        release requires a complete list of providers as described in the first paragraph.
-
-        :param location: current context of the location pointing at the provider mbean
-        """
-        _method_name = '_delete_existing_providers'
-        self.logger.entering(location.get_folder_path(), class_name=self.__class_name, method_name=_method_name)
-
-        list_path = self.alias_helper.get_wlst_list_path(location)
-        existing_folder_names = self._get_existing_folders(list_path)
-        wlst_base_provider_type = self.alias_helper.get_wlst_mbean_type(location)
-        if len(existing_folder_names) == 0:
-            self.logger.finer('WLSDPLY-12136', wlst_base_provider_type, list_path, class_name=self.__class_name,
-                              method_name=_method_name)
-        else:
-            create_path = self.alias_helper.get_wlst_create_path(location)
-            self.wlst_helper.cd(create_path)
-            for existing_folder_name in existing_folder_names:
-                try:
-                    self.logger.info('WLSDPLY-12135', existing_folder_name, wlst_base_provider_type, create_path,
-                                     class_name=self.__class_name, method_name=_method_name)
-                    self.wlst_helper.delete(existing_folder_name, wlst_base_provider_type)
-                except BundleAwareException, bae:
-                    ex = exception_helper.create_exception(self._exception_type, 'WLSDPLY-12134', existing_folder_name,
-                                                           self.wls_helper.get_weblogic_version(),
-                                                           wlst_base_provider_type, bae.getLocalizedMessage(),
-                                                           error=bae)
-                    self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
-                    raise ex
-
-        self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
-        return
-
     def _get_existing_folders(self, wlst_path):
         """
         Get the list of existing folders at the specified WLST path.