class Creator(object): """ The base class used by the DomainCreator. """ __class_name = 'Creator' def __init__(self, model, model_context, aliases, exception_type=ExceptionType.CREATE, logger=PlatformLogger('wlsdeploy.create')): self.logger = logger self.aliases = aliases self._exception_type = exception_type self.alias_helper = AliasHelper(self.aliases, self.logger, exception_type) self.wlst_helper = WlstHelper(self.logger, exception_type) self.model = Model(model) self.model_context = model_context self.wls_helper = WebLogicHelper(self.logger) self.attribute_setter = AttributeSetter(self.aliases, self.logger, exception_type) self.custom_folder_helper = CustomFolderHelper(self.aliases, self.logger, self.model_context, exception_type) # Must be initialized by the subclass since only it has # the knowledge required to compute the domain name. self.archive_helper = None self.files_to_extract_from_archive = list() return def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False): """ Create the specified type of MBeans that support multiple instances in the specified location. :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_named_mbeans' self.logger.entering(type_name, str(base_location), log_created, class_name=self.__class_name, method_name=_method_name) if model_nodes is None or len( model_nodes) == 0 or not self._is_type_valid( base_location, type_name): return location = LocationContext(base_location).append_location(type_name) self._process_flattened_folder(location) 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) for model_name in model_nodes: name = self.wlst_helper.get_quoted_name_for_wlst(model_name) if token_name is not None: location.add_name_token(token_name, name) wlst_type, wlst_name = self.alias_helper.get_wlst_mbean_type_and_name( location) if wlst_name not in existing_folder_names: if log_created: self.logger.info('WLSDPLY-12100', type_name, name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12100', type_name, name, class_name=self.__class_name, method_name=_method_name) self.wlst_helper.create_and_cd(self.alias_helper, wlst_type, wlst_name, location, create_path) else: if log_created: self.logger.info('WLSDPLY-12101', type_name, name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12101', type_name, name, class_name=self.__class_name, method_name=_method_name) attribute_path = self.alias_helper.get_wlst_attributes_path( location) self.wlst_helper.cd(attribute_path) child_nodes = dictionary_utils.get_dictionary_element( model_nodes, name) self._process_child_nodes(location, child_nodes) self.logger.exiting(class_name=self.__class_name, method_name=_method_name) return def _create_mbean(self, type_name, model_nodes, base_location, log_created=False): """ Create the specified type of MBean that support a single instance in the specified location. :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 MBean :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_mbean' self.logger.entering(type_name, str(base_location), log_created, class_name=self.__class_name, method_name=_method_name) if model_nodes is None or len( model_nodes) == 0 or not self._is_type_valid( base_location, type_name): return location = LocationContext(base_location).append_location(type_name) result, message = self.alias_helper.is_version_valid_location(location) if result == ValidationCodes.VERSION_INVALID: self.logger.warning('WLSDPLY-12123', message, class_name=self.__class_name, method_name=_method_name) return create_path = self.alias_helper.get_wlst_create_path(location) existing_folder_names = self._get_existing_folders(create_path) mbean_type, mbean_name = self.alias_helper.get_wlst_mbean_type_and_name( location) token_name = self.alias_helper.get_name_token(location) if token_name is not None: if self.alias_helper.requires_unpredictable_single_name_handling( location): existing_subfolder_names = deployer_utils.get_existing_object_list( location, self.alias_helper) if len(existing_subfolder_names) > 0: mbean_name = existing_subfolder_names[0] location.add_name_token(token_name, mbean_name) self._process_flattened_folder(location) if mbean_type not in existing_folder_names: if log_created: self.logger.info('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) self.wlst_helper.create_and_cd(self.alias_helper, mbean_type, mbean_name, location, create_path) else: if log_created: self.logger.info('WLSDPLY-20013', type_name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) attribute_path = self.alias_helper.get_wlst_attributes_path( location) self.wlst_helper.cd(attribute_path) self._process_child_nodes(location, model_nodes) self.logger.exiting(class_name=self.__class_name, method_name=_method_name) return def _create_named_subtype_mbeans(self, type_name, model_nodes, base_location, log_created=False): """ 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 """ 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] # don't check for empty subfolder nodes here, some create methods allow them sub_location = LocationContext(location).append_location(key) 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.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 _process_child_nodes(self, location, model_nodes): """ Process the model nodes at the specified location. The default behavior is to process attributes, then sub-folders. Sub-classes may override to reverse this order, or for other special processing. :param location: the location where the nodes should be applied :param model_nodes: the model dictionary of the nodes to be applied :raises: CreateException: if an error occurs """ _method_name = '_process_child_nodes' self.logger.finest('WLSDPLY-12111', self.alias_helper.get_model_folder_path(location), self.wlst_helper.get_pwd(), class_name=self.__class_name, method_name=_method_name) self._set_attributes(location, model_nodes) self._create_subfolders(location, model_nodes) def _set_attributes(self, location, model_nodes): """ Set the attributes for the MBean at the specified location. :param location: the location :param model_nodes: the model dictionary :raises: CreateException: if an error occurs """ _method_name = '_set_attributes' model_attribute_names = self.alias_helper.get_model_attribute_names_and_types( location) password_attribute_names = self.alias_helper.get_model_password_type_attribute_names( location) set_method_map = self.alias_helper.get_model_mbean_set_method_attribute_names_and_types( location) uses_path_tokens_attribute_names = self.alias_helper.get_model_uses_path_tokens_attribute_names( location) model_folder_path = self.alias_helper.get_model_folder_path(location) pwd = self.wlst_helper.get_pwd() for key, value in model_nodes.iteritems(): if key in model_attribute_names: if key in set_method_map: self.logger.finest('WLSDPLY-12112', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_mbean_attribute(location, key, value, set_method_map) elif key in password_attribute_names: self.logger.finest('WLSDPLY-12113', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_attribute(location, key, value, uses_path_tokens_attribute_names, masked=True) else: self.logger.finest('WLSDPLY-12113', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_attribute(location, key, value, uses_path_tokens_attribute_names) return def _set_mbean_attribute(self, location, model_key, model_value, set_method_map): """ Set the attributes for the MBean that require an MBean value to set at the specified location. :param location: the location :param model_key: the model attribute name :param model_value: the model attribute value :param set_method_map: the set method map that maps the attribute names requiring MBean values to the attribute setter method name :raises: CreateException: if an error occurs """ _method_name = '_set_mbean_attribute' set_method_info = dictionary_utils.get_dictionary_element( set_method_map, model_key) set_method_name = dictionary_utils.get_element(set_method_info, 'set_method') if set_method_name is not None: try: self.logger.finest('WLSDPLY-12114', model_key, model_value, set_method_name, class_name=self.__class_name, method_name=_method_name) set_method = getattr(self.attribute_setter, set_method_name) set_method(location, model_key, model_value, None) except AttributeError, ae: ex = exception_helper.create_create_exception( 'WLSDPLY-12104', set_method_name, model_key, self.alias_helper.get_model_folder_path(location), error=ae) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex else:
class CustomFolderHelper(object): """ Shared code for custom (user-defined) folders in the model. These require special handling, since they do not have alias definitions. """ __class_name = 'CustomFolderHelper' __cipher_text_prefixes = ["{AES}", "{AES-256}"] def __init__(self, aliases, logger, model_context, exception_type): self.logger = logger self.model_context = model_context self.exception_type = exception_type self.alias_helper = AliasHelper(aliases, self.logger, self.exception_type) self.weblogic_helper = WebLogicHelper(self.logger) self.wlst_helper = WlstHelper(self.logger, self.exception_type) def update_security_folder(self, location, model_type, model_subtype, model_name, model_nodes): """ Update the specified security model nodes in WLST. :param location: the location for the provider :param model_type: the type of the provider to be updated, such as AuthenticationProvider :param model_subtype: the subtype of the provider to be updated, such as 'custom.my.CustomIdentityAsserter' :param model_name: the name of the provider to be updated, such as 'My custom IdentityAsserter' :param model_nodes: a child model nodes of the provider to be updated :raises: BundleAwareException of the specified type: if an error occurs """ _method_name = 'update_security_folder' location_path = self.alias_helper.get_model_folder_path(location) self.logger.entering(location_path, model_subtype, model_name, class_name=self.__class_name, method_name=_method_name) self.logger.info('WLSDPLY-12124', model_type, model_name, model_subtype, location_path, class_name=self.__class_name, method_name=_method_name) create_path = self.alias_helper.get_wlst_subfolders_path(location) self.wlst_helper.cd(create_path) # create the MBean using the model type, name, and subtype type_location = LocationContext(location).append_location(model_type) token = self.alias_helper.get_name_token(type_location) type_location.add_name_token(token, model_name) mbean_type = self.alias_helper.get_wlst_mbean_type(type_location) self.wlst_helper.create(model_name, model_subtype, mbean_type) provider_path = self.alias_helper.get_wlst_attributes_path( type_location) provider_mbean = self.wlst_helper.cd(provider_path) interface_name = model_subtype + 'MBean' bean_info = self.weblogic_helper.get_bean_info_for_interface( interface_name) if bean_info is None: ex = exception_helper.create_exception(self.exception_type, 'WLSDPLY-12125', interface_name) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex property_map = dict() for property_descriptor in bean_info.getPropertyDescriptors(): self.logger.finer('WLSDPLY-12126', str(property_descriptor), class_name=self.__class_name, method_name=_method_name) property_map[property_descriptor.getName()] = property_descriptor for model_key in model_nodes: model_value = model_nodes[model_key] property_descriptor = property_map.get(model_key) if not property_descriptor: ex = exception_helper.create_exception(self.exception_type, 'WLSDPLY-12128', model_key) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex # find the setter method for the attribute method = property_descriptor.writeMethod if not method: # this must be a read-only attribute, just log it and continue with next attribute self.logger.info('WLSDPLY-12129', str(model_key), class_name=self.__class_name, method_name=_method_name) continue self.logger.finer('WLSDPLY-12127', str(model_key), str(model_value), class_name=self.__class_name, method_name=_method_name) # determine the data type from the set method parameter_types = method.getParameterTypes() parameter_count = len(parameter_types) if parameter_count != 1: ex = exception_helper.create_exception(self.exception_type, 'WLSDPLY-12130', model_key, parameter_count) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex # if the property requires encryption, and the value is not encrypted, # encrypt the value with domain encryption. requires_encrypted = property_descriptor.getValue('encrypted') if requires_encrypted and not self.is_encrypted( model_value) and isinstance(model_value, str): model_value = self.weblogic_helper.encrypt( model_value, self.model_context.get_domain_home()) property_type = parameter_types[0] # convert the model value to the target type and call the setter with the target value. # these are done together in Java to avoid automatic Jython type conversions. try: CustomBeanUtils.callMethod(provider_mbean, method, property_type, model_value) # failure converting value or calling method except (IllegalAccessException, IllegalArgumentException, InvocationTargetException), ex: ex = exception_helper.create_exception( self.exception_type, 'WLSDPLY-12131', method, str(model_value), ex.getLocalizedMessage(), error=ex) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex
class Creator(object): """ The base class used by the DomainCreator. """ __class_name = 'Creator' def __init__(self, model, model_context, aliases, exception_type=ExceptionType.CREATE, logger=PlatformLogger('wlsdeploy.create')): self.logger = logger self.aliases = aliases self.alias_helper = AliasHelper(self.aliases, self.logger, exception_type) self.wlst_helper = WlstHelper(self.logger, exception_type) self.model = Model(model) self.model_context = model_context self.wls_helper = WebLogicHelper(self.logger) self.attribute_setter = AttributeSetter(self.aliases, self.logger, exception_type) # Must be initialized by the subclass since only it has # the knowledge required to compute the domain name. self.archive_helper = None self.files_to_extract_from_archive = list() return def _create_named_mbeans(self, type_name, model_nodes, base_location, log_created=False): """ Create the specified type of MBeans that support multiple instances in the specified location. :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_named_mbeans' self.logger.entering(type_name, str(base_location), log_created, class_name=self.__class_name, method_name=_method_name) if model_nodes is None or len( model_nodes) == 0 or not self._is_type_valid( base_location, type_name): return location = LocationContext(base_location).append_location(type_name) self._process_flattened_folder(location) 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) for model_name in model_nodes: name = self.wlst_helper.get_quoted_name_for_wlst(model_name) if token_name is not None: location.add_name_token(token_name, name) wlst_type, wlst_name = self.alias_helper.get_wlst_mbean_type_and_name( location) if wlst_name not in existing_folder_names: if log_created: self.logger.info('WLSDPLY-12100', type_name, name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12100', type_name, name, class_name=self.__class_name, method_name=_method_name) self.wlst_helper.create_and_cd(self.alias_helper, wlst_type, wlst_name, location, create_path) else: if log_created: self.logger.info('WLSDPLY-12101', type_name, name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12101', type_name, name, class_name=self.__class_name, method_name=_method_name) attribute_path = self.alias_helper.get_wlst_attributes_path( location) self.wlst_helper.cd(attribute_path) child_nodes = dictionary_utils.get_dictionary_element( model_nodes, name) self.logger.finest( 'WLSDPLY-12111', self.alias_helper.get_model_folder_path(location), self.wlst_helper.get_pwd(), class_name=self.__class_name, method_name=_method_name) self._set_attributes(location, child_nodes) self._create_subfolders(location, child_nodes) self.logger.exiting(class_name=self.__class_name, method_name=_method_name) return def _create_mbean(self, type_name, model_nodes, base_location, log_created=False): """ Create the specified type of MBean that support a single instance in the specified location. :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 MBean :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_mbean' self.logger.entering(type_name, str(base_location), log_created, class_name=self.__class_name, method_name=_method_name) if model_nodes is None or len( model_nodes) == 0 or not self._is_type_valid( base_location, type_name): return location = LocationContext(base_location).append_location(type_name) result, message = self.alias_helper.is_version_valid_location(location) if result == ValidationCodes.VERSION_INVALID: self.logger.warning('WLSDPLY-12123', message, class_name=self.__class_name, method_name=_method_name) return create_path = self.alias_helper.get_wlst_create_path(location) existing_folder_names = self._get_existing_folders(create_path) mbean_type, mbean_name = self.alias_helper.get_wlst_mbean_type_and_name( location) token_name = self.alias_helper.get_name_token(location) if token_name is not None: location.add_name_token(token_name, mbean_name) self._process_flattened_folder(location) if mbean_type not in existing_folder_names: if log_created: self.logger.info('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) self.wlst_helper.create_and_cd(self.alias_helper, mbean_type, mbean_name, location, create_path) else: if log_created: self.logger.info('WLSDPLY-20013', type_name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12102', type_name, class_name=self.__class_name, method_name=_method_name) attribute_path = self.alias_helper.get_wlst_attributes_path( location) self.wlst_helper.cd(attribute_path) self.logger.finest('WLSDPLY-12111', self.alias_helper.get_model_folder_path(location), self.wlst_helper.get_pwd(), class_name=self.__class_name, method_name=_method_name) self._set_attributes(location, model_nodes) self._create_subfolders(location, model_nodes) 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): """ Create the specified security provider MBean types that support multiple instances but use an artificial type subfolder in the specified location. :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 model_nodes is None or len( model_nodes) == 0 or not self._is_type_valid( base_location, type_name): return location = LocationContext(base_location).append_location(type_name) self._process_flattened_folder(location) 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) for model_name in model_nodes: 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) wlst_base_provider_type, wlst_name = self.alias_helper.get_wlst_mbean_type_and_name( prov_location) model_node = model_nodes[model_name] if model_node is not None: if len(model_node) == 1: model_type_subfolder_name = list(model_node.keys())[0] prov_location.append_location(model_type_subfolder_name) wlst_type = self.alias_helper.get_wlst_mbean_type( prov_location) else: ex = exception_helper.create_create_exception( 'WLSDPLY-12117', type_name, model_name, len(model_node)) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex else: # The node is empty so nothing to do...move to the next named node. continue if wlst_name not in existing_folder_names: if log_created: self.logger.info('WLSDPLY-12118', type_name, model_type_subfolder_name, name, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12118', type_name, model_type_subfolder_name, name, 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, class_name=self.__class_name, method_name=_method_name) else: self.logger.fine('WLSDPLY-12119', type_name, model_type_subfolder_name, name, 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) child_nodes = dictionary_utils.get_dictionary_element( model_node, model_type_subfolder_name) 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.exiting(class_name=self.__class_name, method_name=_method_name) return def _set_attributes(self, location, model_nodes): """ Set the attributes for the MBean at the specified location. :param location: the location :param model_nodes: the model dictionary :raises: CreateException: if an error occurs """ _method_name = '_set_attributes' model_attribute_names = self.alias_helper.get_model_attribute_names_and_types( location) password_attribute_names = self.alias_helper.get_model_password_type_attribute_names( location) set_method_map = self.alias_helper.get_model_mbean_set_method_attribute_names_and_types( location) uses_path_tokens_attribute_names = self.alias_helper.get_model_uses_path_tokens_attribute_names( location) model_folder_path = self.alias_helper.get_model_folder_path(location) pwd = self.wlst_helper.get_pwd() for key, value in model_nodes.iteritems(): if key in model_attribute_names: if key in set_method_map: self.logger.finest('WLSDPLY-12112', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_mbean_attribute(location, key, value, set_method_map) elif key in password_attribute_names: self.logger.finest('WLSDPLY-12113', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_attribute(location, key, value, uses_path_tokens_attribute_names, masked=True) else: self.logger.finest('WLSDPLY-12113', key, pwd, model_folder_path, class_name=self.__class_name, method_name=_method_name) self._set_attribute(location, key, value, uses_path_tokens_attribute_names) return def _set_mbean_attribute(self, location, model_key, model_value, set_method_map): """ Set the attributes for the MBean that require an MBean value to set at the specified location. :param location: the location :param model_key: the model attribute name :param model_value: the model attribute value :param set_method_map: the set method map that maps the attribute names requiring MBean values to the attribute setter method name :raises: CreateException: if an error occurs """ _method_name = '_set_mbean_attribute' set_method_info = dictionary_utils.get_dictionary_element( set_method_map, model_key) set_method_name = dictionary_utils.get_element(set_method_info, 'set_method') if set_method_name is not None: try: self.logger.finest('WLSDPLY-12114', model_key, model_value, set_method_name, class_name=self.__class_name, method_name=_method_name) set_method = getattr(self.attribute_setter, set_method_name) set_method(location, model_key, model_value, None) except AttributeError, ae: ex = exception_helper.create_create_exception( 'WLSDPLY-12104', set_method_name, model_key, self.alias_helper.get_model_folder_path(location), error=ae) self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name) raise ex else:
class PrepareModel: """ This is the main driver for the caller. It compares two model files whether they are json or yaml format. """ def __init__(self, model_files, model_context, logger, output_dir=None): self.model_files = model_files self.output_dir = output_dir self.model_context = model_context self._aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE) self._alias_helper = AliasHelper(self._aliases, logger, ExceptionType.COMPARE) self._logger = logger self._name_tokens_location = LocationContext() self._name_tokens_location.add_name_token('DOMAIN', "testdomain") self.current_dict = None self.cache = OrderedDict() self.secrets_to_generate = sets.Set() def __walk_model_section(self, model_section_key, model_dict, valid_section_folders): _method_name = '__validate_model_section' if model_section_key not in model_dict.keys(): return # only specific top-level sections have attributes attribute_location = self._alias_helper.get_model_section_attribute_location(model_section_key) valid_attr_infos = [] path_tokens_attr_keys = [] if attribute_location is not None: valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(attribute_location) path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names(attribute_location) model_section_dict = model_dict[model_section_key] for section_dict_key, section_dict_value in model_section_dict.iteritems(): # section_dict_key is either the name of a folder in the # section, or the name of an attribute in the section. validation_location = LocationContext() model_folder_path = model_section_key + ":/" if section_dict_key in valid_attr_infos: # section_dict_key is the name of an attribute in the section self.__walk_attribute(section_dict_key, section_dict_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, attribute_location) elif section_dict_key in valid_section_folders: # section_dict_key is a folder under the model section # Append section_dict_key to location context validation_location.append_location(section_dict_key) # Call self.__validate_section_folder() passing in section_dict_value as the model_node to process self.__walk_section_folder(section_dict_value, validation_location) def __walk_section_folder(self, model_node, validation_location): _method_name = '__validate_section_folder' model_folder_path = self._alias_helper.get_model_folder_path(validation_location) if self._alias_helper.supports_multiple_mbean_instances(validation_location): for name in model_node: expanded_name = name new_location = LocationContext(validation_location) name_token = self._alias_helper.get_name_token(new_location) if name_token is not None: new_location.add_name_token(name_token, expanded_name) value_dict = model_node[name] self.__walk_model_node(value_dict, new_location) elif self._alias_helper.requires_artificial_type_subfolder_handling(validation_location): for name in model_node: expanded_name = name new_location = LocationContext(validation_location) name_token = self._alias_helper.get_name_token(new_location) if name_token is not None: new_location.add_name_token(name_token, expanded_name) value_dict = model_node[name] self.__walk_model_node(value_dict, new_location) else: name_token = self._alias_helper.get_name_token(validation_location) if name_token is not None: name = self._name_tokens_location.get_name_for_token(name_token) if name is None: name = '%s-0' % name_token validation_location.add_name_token(name_token, name) self.__walk_model_node(model_node, validation_location) def __walk_model_node(self, model_node, validation_location): _method_name = '__process_model_node' valid_folder_keys = self._alias_helper.get_model_subfolder_names(validation_location) valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(validation_location) model_folder_path = self._alias_helper.get_model_folder_path(validation_location) for key, value in model_node.iteritems(): if key in valid_folder_keys: new_location = LocationContext(validation_location).append_location(key) if self._alias_helper.is_artificial_type_folder(new_location): # key is an ARTIFICIAL_TYPE folder valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types(new_location) self.__walk_attributes(value, valid_attr_infos, new_location) else: self.__walk_section_folder(value, new_location) elif key in valid_attr_infos: # aliases.get_model_attribute_names_and_types(location) filters out # attributes that ARE NOT valid in the wlst_version being used, so if # we're in this section of code we know key is a bonafide "valid" attribute valid_data_type = valid_attr_infos[key] if valid_data_type in ['properties']: valid_prop_infos = {} properties = validation_utils.get_properties(value) self.__walk_properties(properties, valid_prop_infos, validation_location) else: path_tokens_attr_keys = \ self._alias_helper.get_model_uses_path_tokens_attribute_names(validation_location) self.__walk_attribute(key, value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location) def __walk_attributes(self, attributes_dict, valid_attr_infos, validation_location): _method_name = '__validate_attributes' path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names(validation_location) model_folder_path = self._alias_helper.get_model_folder_path(validation_location) for attribute_name, attribute_value in attributes_dict.iteritems(): self.__walk_attribute(attribute_name, attribute_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location) def __walk_attribute(self, attribute_name, attribute_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location): _method_name = '__validate_attribute' if attribute_name in valid_attr_infos: expected_data_type = valid_attr_infos[attribute_name] if expected_data_type == 'password': self.__substitute_password_with_token(model_folder_path, attribute_name, validation_location) self._logger.exiting(class_name=_class_name, method_name=_method_name) def __walk_properties(self, properties_dict, valid_prop_infos, validation_location): _method_name = '__walk_properties' for property_name, property_value in properties_dict.iteritems(): valid_prop_infos[property_name] = validation_utils.get_python_data_type(property_value) self.__walk_property(property_name, property_value, valid_prop_infos, validation_location) def __walk_property(self, property_name, property_value, valid_prop_infos, model_folder_path, validation_location): _method_name = '__walk_property' self._logger.entering(property_name, property_value, str(valid_prop_infos), model_folder_path, class_name=_class_name, method_name=_method_name) if property_name in valid_prop_infos: expected_data_type = valid_prop_infos[property_name] if expected_data_type == 'password': self.__substitute_password_with_token(model_folder_path, property_name, validation_location) def __format_variable_name(self, location, attribute): _method_name = '__format_variable_name' def __traverse_location(iterate_location, name_list, last_folder=None, last_folder_short=None): current_folder = iterate_location.get_current_model_folder() if current_folder == model_constants.DOMAIN: if last_folder is not None: # If a short name is not defined for the top level folder, use the full name if len(last_folder_short) == 0: last_folder_short = last_folder name_list.insert(0, last_folder_short) else: current_folder = iterate_location.get_current_model_folder() short_folder = self._aliases.get_folder_short_name(iterate_location) if last_folder_short is not None: name_list.insert(0, last_folder_short) try: if not self._aliases.is_artificial_type_folder(location) and \ (self._aliases.supports_multiple_mbean_instances(iterate_location) or self._aliases.is_custom_folder_allowed(iterate_location)): name_token = self._aliases.get_name_token(iterate_location) name = iterate_location.get_name_for_token(name_token) name_list.insert(0, name) iterate_location.remove_name_token(name_token) iterate_location.pop_location() except AliasException, ae: self._logger.warning('WLSDPLY-19531', str(location), attribute, ae.getLocalizedMessage(), class_name=_class_name, method_name=_method_name) __traverse_location(iterate_location, name_list, current_folder, short_folder) return name_list short_list = __traverse_location(LocationContext(location), list()) short_name = '' for node in short_list: if node is not None and len(node) > 0: short_name += node + '.' short_name += attribute _fake_name_replacement = re.compile('.fakename') _white_space_replacement = re.compile('\s') short_name = short_name.replace('/', '.') short_name = _white_space_replacement.sub('-', short_name) short_name = _fake_name_replacement.sub('', short_name) return short_name
class AttributeSetter(object): """ Contains the "set" methods used to set WLST values that require mbeans or other special processing. The public set_ methods in this class correspond directly to the set_method names in the alias files. The signature for each set_ method is (location, key, value), where key and value are from the model. """ # used for target search __target_type_names = [ CLUSTER, SERVER, MIGRATABLE_TARGET, ] # used for destination search __destination_type_names = [ QUEUE, TOPIC, DISTRIBUTED_QUEUE, DISTRIBUTED_TOPIC, UNIFORM_DISTRIBUTED_QUEUE, UNIFORM_DISTRIBUTED_TOPIC ] # used for SAF destination search __saf_destination_type_names = [ SAF_QUEUE, SAF_TOPIC ] # used for persistent store search __persistent_store_type_names = [ FILE_STORE, JDBC_STORE ] # used for self-tuning deployment and attribute processing. # these names are applicable as self-tuning sub-folder names, and work manager attribute names. # work manager is intentionally excluded and treated separately. __self_tuning_type_names = [ CAPACITY, CONTEXT_REQUEST_CLASS, FAIR_SHARE_REQUEST_CLASS, MAX_THREADS_CONSTRAINT, MIN_THREADS_CONSTRAINT, RESPONSE_TIME_REQUEST_CLASS ] # used for WLDF watch notification search __watch_action_types = [ HEAP_DUMP_ACTION, IMAGE_NOTIFICATION, JMS_NOTIFICATION, JMX_NOTIFICATION, LOG_ACTION, REST_NOTIFICATION, SCRIPT_ACTION, SMTP_NOTIFICATION, SNMP_NOTIFICATION, THREAD_DUMP_ACTION ] _class_name = "AttributeSetter" def __init__(self, aliases, logger, exception_type, wlst_mode=WlstModes.OFFLINE): self.__logger = logger self.__exception_type = exception_type self.__wlst_mode = wlst_mode self.__alias_helper = AliasHelper(aliases, self.__logger, exception_type) self.__wlst_helper = WlstHelper(self.__logger, exception_type) return # # public set_ methods for special attribute types, signature (self, location, key, value, wlst_value, ...) # def set_target_jms_mbeans(self, location, key, value, wlst_value): """ Set the target MBeans for targets that can include JMS resources (e.g., JMSServer). :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ self.set_target_mbeans(location, key, value, wlst_value, include_jms=True) return def set_target_mbeans(self, location, key, value, wlst_value, include_jms=False): """ Set the target MBeans. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :param include_jms: whether or not to include JMS resources :raises BundleAwareException of the specified type: if target is not found """ targets_value = self.__build_target_mbean_list(value, wlst_value, location, include_jms=include_jms) self.set_attribute(location, key, targets_value, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jms_error_destination_mbean(self, location, key, value, wlst_value): """ Set the JMS Error Destination MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if destination is not found """ mbean = self.__find_jms_destination_mbean(location, value) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jms_bridge_destination_mbean(self, location, key, value, wlst_value): """ Set the JMS Bridge Destination MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if destination is not found """ mbean = self.__find_in_resource_group_or_domain(location, JMS_BRIDGE_DESTINATION, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_persistent_store_mbean(self, location, key, value, wlst_value): """ Set the Persistent Store MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if store is not found """ mbean = self.__find_persistent_store(location, value) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_data_source_mbean(self, location, key, value, wlst_value): """ Set the DataSource MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if DataSource is not found """ mbean = self.__find_in_resource_group_or_domain(location, JDBC_SYSTEM_RESOURCE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_saf_remote_context_mbean(self, location, key, value, wlst_value): """ Set the SAF RemoteContext MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if SAF RemoteContext is not found """ resource_location = self.__get_parent_location(location, JMS_RESOURCE) mbean = self.__find_in_location(resource_location, SAF_REMOTE_CONTEXT, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_saf_error_destination_mbean(self, location, key, value, wlst_value): """ Set the SAF Error Destination MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if destination is not found """ mbean = self.__find_saf_destination_mbean(location, value) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_saf_error_handling_mbean(self, location, key, value, wlst_value): """ Set the SAF Error Handling MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if destination is not found """ resource_location = self.__get_parent_location(location, JMS_RESOURCE) mbean = self.__find_in_location(resource_location, SAF_ERROR_HANDLING, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_self_tuning_mbean(self, location, key, value, wlst_value): """ Set the SelfTuning MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if MBean is not found """ tuning_location = self.__get_parent_location(location, SELF_TUNING) mbean = self.__find_in_location(tuning_location, key, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_server_mbeans(self, location, key, value, wlst_value): """ Set the Server MBeans. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if a server is not found """ mbeans = self.__build_server_mbean_list(value, wlst_value) self.set_attribute(location, key, mbeans, wlst_merge_value=wlst_value, use_raw_value=True) return def set_server_mbean(self, location, key, value, wlst_value): """ Set the Server MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the server is not found """ mbean = self.__find_in_location(LocationContext(), SERVER, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_server_template_mbean(self, location, key, value, wlst_value): """ Set the Server Template MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the server template is not found """ mbean = self.__find_in_location(LocationContext(), SERVER_TEMPLATE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_cluster_mbean(self, location, key, value, wlst_value): """ Set the Cluster MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the cluster is not found """ mbean = self.__find_in_location(LocationContext(), CLUSTER, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_server_cluster_mbean(self, location, key, value, wlst_value): """ assign the Cluster MBean to a server. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the cluster is not found """ entity_type, entity_name = self.__alias_helper.get_model_type_and_name(location) self.__wlst_helper.assign(entity_type, entity_name, key, value) return def set_coherence_cluster_mbean(self, location, key, value, wlst_value): """ Set the Log Filter MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if store is not found """ mbean = self.__find_in_location(LocationContext(), COHERENCE_CLUSTER_SYSTEM_RESOURCE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_machine_mbean(self, location, key, value, wlst_value): """ Set the Machine MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the machine is not found """ mbean = self.__find_in_location(LocationContext(), MACHINE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jms_template_mbean(self, location, key, value, wlst_value): """ Set the JMS Template MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the JMS Template is not found """ resource_location = self.__get_parent_location(location, JMS_RESOURCE) mbean = self.__find_in_location(resource_location, TEMPLATE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_wldf_action_mbeans(self, location, key, value, wlst_value): """ Set the WLDF Action/Notification MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if the WLDF Action/Notification is not found """ watch_location = self.__get_parent_location(location, WATCH_NOTIFICATION) action_names = TypeUtils.convertToType(List, value) # type: list of str action_names = self.__merge_existing_items(action_names, wlst_value) action_mbeans = [] for action_name in action_names: action_mbean = self.__find_wldf_action(watch_location, action_name) action_mbeans.append(action_mbean) if self.__wlst_mode == WlstModes.ONLINE: # for online, call the current location's add method for each action mbean location_mbean = self.__wlst_helper.cd(self.__wlst_helper.get_pwd()) for action_mbean in action_mbeans: location_mbean.addNotification(action_mbean) else: self.set_attribute(location, key, action_mbeans, wlst_merge_value=wlst_value, use_raw_value=True) return def set_log_filter_mbean(self, location, key, value, wlst_value): """ Set the Log Filter MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if store is not found """ mbean = self.__find_in_location(LocationContext(), LOG_FILTER, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jms_server_mbean(self, location, key, value, wlst_value): """ For those entities, such as WLSReliableDeliveryPolicy, that take a single JMS Server mbean. :param location: location to look for jms server :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if jms server mbean is not found. """ mbean = self.__find_in_location(LocationContext(), JMS_SERVER, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jms_quota_mbean(self, location, key, value, wlst_value): """ For those entities, queues, template, topics, that take a single Quota mbean. :param location: location to look for Quota mbean :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if quota mbean is not found. """ resource_location = self.__get_parent_location(location, JMS_RESOURCE) mbean = self.__find_in_location(resource_location, QUOTA, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_reliable_delivery_policy_mbean(self, location, key, value, wlst_value): """ Sets the ws soap reliable delivery policy mbean used by mbeans like Server and Server Template. :param location: location to look for reliable delivery policy :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if reliable delivery policy mbean is not found. """ mbean = self.__find_in_location(LocationContext(), WS_RELIABLE_DELIVERY_POLICY, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_xml_entity_cache_mbean(self, location, key, value, wlst_value): """ Sets the XML cache mbean used by topology entities such as Server. :param location: location to look for reliable delivery policy :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if xml entity cache mbean is not found. """ mbean = self.__find_in_location(LocationContext(), XML_ENTITY_CACHE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_xml_registry_mbean(self, location, key, value, wlst_value): """ Sets the XML registry mbean used by topology entities such as Server. :param location: location to look for reliable delivery policy :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if xml registry mbean is not found. """ mbean = self.__find_in_location(LocationContext(), XML_REGISTRY, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_mt_target_mbeans(self, location, key, value, wlst_value): """ Set the virtual target MBeans. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ targets_value = self.__build_virtual_target_mbean_list(value, wlst_value) self.set_attribute(location, key, targets_value, wlst_merge_value=wlst_value, use_raw_value=True) return def set_security_realm_mbean(self, location, key, value, wlst_value): """ Set the security realm MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ security_location = self.__get_domain_location(location).append_location(SECURITY_CONFIGURATION) mbean = self.__find_in_location(security_location, REALM, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_certificate_registry_mbean(self, location, key, value, wlst_value): """ Set the certificate registry MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ realm_location = self.__get_parent_location(location, REALM) mbean = self.__find_in_location(realm_location, CERT_PATH_PROVIDER, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_resource_group_template_mbean(self, location, key, value, wlst_value): """ Set the resource group template MBean. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ domain_location = self.__get_domain_location(location) mbean = self.__find_in_location(domain_location, RESOURCE_GROUP_TEMPLATE, value, required=True) self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_partition_work_manager_mbean(self, location, key, value, wlst_value): """ Set the partition work manager MBean. Search in the same partition, then at the domain level. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ method_name = 'set_partition_work_manager_mbean' partition_location = self.__get_parent_location(location, PARTITION) mbean = self.__find_in_location(partition_location, PARTITION_WORK_MANAGER, value) if mbean is None: domain_location = self.__get_domain_location(location) mbean = self.__find_in_location(domain_location, PARTITION_WORK_MANAGER, value) if mbean is None: _type, partition_name = self.__alias_helper.get_model_type_and_name(location) ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19206', value, partition_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_resource_manager_mbean(self, location, key, value, wlst_value): """ Set the resource manager MBean. Search in the same partition, then at the domain level. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ method_name = 'set_resource_manager_mbean' partition_location = self.__get_parent_location(location, PARTITION) mbean = self.__find_in_location(partition_location, RESOURCE_MANAGER, value) if mbean is None: management_location = self.__get_domain_location(location).append_location(RESOURCE_MANAGEMENT) mbean = self.__find_in_location(management_location, RESOURCE_MANAGER, value) if mbean is None: _type, manager_name = self.__alias_helper.get_model_type_and_name(location) ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19207', value, manager_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex self.set_attribute(location, key, mbean, wlst_merge_value=wlst_value, use_raw_value=True) return def set_jvm_args(self, location, key, value, wlst_value): """ Set the server start args string. The new arguments are merged and re-sorted with existing arguments. :param location: the location :param key: the attribute name :param value: the string value :param wlst_value: the existing value of the attribute from WLST :raises BundleAwareException of the specified type: if target is not found """ if value is None or len(value) == 0: result = value elif wlst_value is None or len(wlst_value) == 0: new_args = JVMArguments(self.__logger, value) result = new_args.get_arguments_string() else: new_args = JVMArguments(self.__logger, value) merged_args = JVMArguments(self.__logger, wlst_value) merged_args.merge_jvm_arguments(new_args) result = merged_args.get_arguments_string() self.set_attribute(location, key, result, wlst_merge_value=wlst_value, use_raw_value=True) return # # public set_attribute convenience methods # def set_attribute(self, location, model_key, model_value, wlst_merge_value=None, use_raw_value=False): """ Convenience method for setting the attribute. :param location: location :param model_key: attribute name :param model_value: attribute value :param wlst_merge_value: value from WLST to merge :param use_raw_value: whether or not to the use the model value, default is to use the WLST value :raises BundleAwareException of the specified type: if an error occurs """ _method_name = 'set_attribute' if use_raw_value: wlst_param = self.__alias_helper.get_wlst_attribute_name(location, model_key) wlst_value = model_value else: wlst_param, wlst_value = \ self.__alias_helper.get_wlst_attribute_name_and_value(location, model_key, model_value, existing_wlst_value=wlst_merge_value) if wlst_param is None: self.__logger.info('WLSDPLY-20011', model_key, class_name=self._class_name, method_name=_method_name) elif wlst_value is None: self.__logger.info('WLSDPLY-20012', model_key, str(model_value), class_name=self._class_name, method_name=_method_name) else: self.__wlst_helper.set(wlst_param, wlst_value) return def set_attribute_with_cmo(self, location, key, value, wlst_value=None, masked=False): _method_name = 'set_attribute_with_cmo' wlst_attr_name, wlst_attr_value = \ self.__alias_helper.get_wlst_attribute_name_and_value(location, key, value, existing_wlst_value=wlst_value) if wlst_attr_name is None: self.__logger.info('WLSDPLY-20011', key, class_name=self._class_name, method_name=_method_name) elif wlst_attr_value is None: log_value = str(value) if masked: log_value = '<masked>' self.__logger.info('WLSDPLY-20012', key, log_value, class_name=self._class_name, method_name=_method_name) else: attrib_path = self.__alias_helper.get_wlst_attributes_path(location) self.__wlst_helper.cd(attrib_path) self.__wlst_helper.set_with_cmo(wlst_attr_name, wlst_attr_value, masked=masked) return # # internal lookup methods # def __build_target_mbean_list(self, target_value, wlst_value, location, include_jms=False): """ Construct the target MBean list. :param target_value: the target value :param wlst_value: the existing value from WLST :param include_jms: whether or not to include JMS targets, the default is False :return: the Java array of MBeans ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ target_names = TypeUtils.convertToType(List, target_value) # type: list of str target_names = self.__merge_existing_items(target_names, wlst_value) name_list = [] for target_name in target_names: target_mbean = self.__find_target(target_name, location, include_jms=include_jms) name_list.append(target_mbean.getObjectName()) return jarray.array(name_list, ObjectName) def __build_server_mbean_list(self, value, wlst_value): """ Construct the server MBean list. :param value: the value :param wlst_value: the existing value from WLST :return: the Java array of MBeans ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ server_names = TypeUtils.convertToType(List, value) # type: list of str server_names = self.__merge_existing_items(server_names, wlst_value) name_list = [] for server_name in server_names: mbean = self.__find_in_location(LocationContext(), SERVER, server_name, required=True) name_list.append(mbean.getObjectName()) return jarray.array(name_list, ObjectName) def __build_virtual_target_mbean_list(self, target_value, wlst_value): """ Construct the virtual target MBean list. :param target_value: the target value :param wlst_value: the existing value from WLST :return: for offline, a list of MBeans; for online, a jarray of MBean ObjectNames :raises BundleAwareException of the specified type: if an error occurs """ target_names = TypeUtils.convertToType(List, target_value) # type: list of str target_names = self.__merge_existing_items(target_names, wlst_value) if self.__wlst_mode == WlstModes.ONLINE: name_list = [] for target_name in target_names: target_mbean = self.__find_in_location(LocationContext(), VIRTUAL_TARGET, target_name, required=True) name_list.append(target_mbean.getObjectName()) return jarray.array(name_list, ObjectName) else: mbean_list = [] for target_name in target_names: target_mbean = self.__find_in_location(LocationContext(), VIRTUAL_TARGET, target_name, required=True) mbean_list.append(target_mbean) return mbean_list def __find_target(self, target_name, location, include_jms=False): """ Find a target by name. :param target_name: the target name :param include_jms: whether or not to include JMS in the search, the default is False :return: the MBean for the target :raises BundleAwareException of the specified type: if an error occurs """ method_name = '__find_target' domain_location = self.__get_domain_location(location) for type_name in self.__target_type_names: mbean = self.__find_in_location(domain_location, type_name, target_name) if mbean is not None: return mbean if include_jms: mbean = self.__find_in_resource_group_or_domain(location, JMS_SERVER, target_name) if mbean is not None: return mbean mbean = self.__find_in_resource_group_or_domain(location, SAF_AGENT, target_name) if mbean is not None: return mbean ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19200', target_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex def __find_jms_destination_mbean(self, location, destination_name): """ Find the destination with the specified name and return its WLST mbean. :param location: the WLST location of the attribute :param destination_name: the name of the destination to find :return: the mbean for the destination :raises BundleAwareException of the specified type: if destination is not found """ method_name = '__find_jms_destination_mbean' resource_location = self.__get_parent_location(location, JMS_RESOURCE) for type_name in self.__destination_type_names: mbean = self.__find_in_location(resource_location, type_name, destination_name) if mbean is not None: return mbean _resource_type, resource_name = self.__alias_helper.get_model_type_and_name(resource_location) ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19201', destination_name, resource_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex def __find_persistent_store(self, location, store_name): """ Find the persistent store with the specified name and return its WLST mbean. :param location: the WLST location of the attribute :param store_name: the name of the store to find :return: the mbean for the store :raises BundleAwareException of the specified type: if store is not found """ method_name = '__find_persistent_store' for type_name in self.__persistent_store_type_names: mbean = self.__find_in_resource_group_or_domain(location, type_name, store_name) if mbean is not None: return mbean ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19202', PERSISTENT_STORE, store_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex def __find_saf_destination_mbean(self, location, destination_name): """ Find the SAF destination with the specified name and return its WLST mbean. :param location: the WLST location of the attribute :param destination_name: the name of the SAF destination to find :return: the mbean for the SAF destination :raises BundleAwareException of the specified type: if SAF destination is not found """ method_name = '__find_saf_destination_mbean' resource_location = self.__get_parent_location(location, JMS_RESOURCE) destination_location = LocationContext(resource_location).append_location(SAF_IMPORTED_DESTINATION) existing_sets = self.__get_existing_object_list(destination_location) token_name = self.__alias_helper.get_name_token(destination_location) for set_name in existing_sets: if token_name is not None: destination_location.add_name_token(token_name, set_name) for type_name in self.__saf_destination_type_names: mbean = self.__find_in_location(destination_location, type_name, destination_name) if mbean is not None: return mbean _resource_type, resource_name = self.__alias_helper.get_model_type_and_name(resource_location) ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19203', destination_name, resource_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex def __find_wldf_action(self, watch_location, action_name): """ Find the WLDF action with the specified name and return its WLST mbean. :param watch_location: the WLST location of the watch notification :param action_name: the name of the action to find :return: the mbean for the action :raises BundleAwareException of the specified type: if action is not found """ method_name = '__find_wldf_action' for type_name in self.__watch_action_types: mbean = self.__find_in_location(watch_location, type_name, action_name) if mbean is not None: return mbean ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19202', WATCH_NOTIFICATION, action_name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex def __find_in_resource_group_or_domain(self, location, element_type, name, required=False): """ Find the element with the specified name and type and return its WLST mbean. If the specified location is in a resource group, search only that resource group. :param location: the WLST location of the attribute :param name: the name of the element to find :param required: indicates exception should be thrown if not found :return: the mbean for the destination :raises BundleAwareException of the specified type: if element is not found, and required is True """ method_name = '__find_in_resource_group_or_domain' in_resource_group = RESOURCE_GROUP in location.get_model_folders() if in_resource_group: resource_group_location = self.__get_parent_location(location, RESOURCE_GROUP) mbean = self.__find_in_location(resource_group_location, element_type, name) if mbean is None: template_id = self.__wlst_helper.get("ResourceGroupTemplate") domain_location = self.__get_domain_location(location) mbean = self.__find_in_location(domain_location, RESOURCE_GROUP_TEMPLATE, template_id) else: location = self.__get_domain_location(location) mbean = self.__find_in_location(location, element_type, name) if required and (mbean is None): ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19202', element_type, name) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex return mbean def __find_in_location(self, location, element_type, name, required=False): """ Find the element with the specified name and type and return its WLST mbean. :param location: the WLST location of the attribute :param element_type: the thype of the element to be found :param name: the name of the element to find :param required: indicates exception should be thrown if not found :return: the mbean for the destination :raises BundleAwareException of the specified type: if element is not found, and required is True """ method_name = '__find_in_location' location = LocationContext(location).append_location(element_type) if self.__alias_helper.get_wlst_mbean_type(location) is not None: existing_names = self.__get_existing_object_list(location) if name in existing_names: location_type, location_name = self.__alias_helper.get_model_type_and_name(location) self.__logger.fine('WLSDPLY-19204', element_type, name, location_type, location_name, class_name=self._class_name, method_name=method_name) token = self.__alias_helper.get_name_token(location) location.add_name_token(token, name) path = self.__alias_helper.get_wlst_attributes_path(location) return self.__wlst_helper.get_mbean_for_wlst_path(path) if required: ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19210', element_type, name, self.__alias_helper.get_model_folder_path(location)) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex return None def __get_domain_location(self, location): """ Returns a copy of the specified location with all folders removed, but tokens intact. :param location: the location to be examined :return: the domain location """ _method_name = '__get_domain_location' self.__logger.entering(str(location), class_name=self._class_name, method_name=_method_name) location = LocationContext(location) while len(location.get_model_folders()) > 0: location.pop_location() return location def __get_parent_location(self, location, folder_name): """ Searches the specified location for the specified folder name, and returns the corresponding location. :param location: the location to be examined :param folder_name: the folder name to find :return: the parent location :raises BundleAwareException of the specified type: if the folder is not found in the location folders list """ method_name = '__get_parent_location' try: location = LocationContext(location) resource_index = location.get_model_folders().index(folder_name) while len(location.get_model_folders()) > resource_index + 1: location.pop_location() except: # index throws a ValueError if the item is not in the list... ex = exception_helper.create_exception(self.__exception_type, 'WLSDPLY-19205', folder_name, str(location)) self.__logger.throwing(class_name=self._class_name, method_name=method_name, error=ex) raise ex return location def __get_existing_object_list(self, location): """ Convenience method to get the existing object list by location's list path :param location: the location :return: the list of existing names :raises BundleAwareException of the specified type: if an error occurs """ _method_name = '__get_existing_object_list' self.__logger.entering(str(location), class_name=self._class_name, method_name=_method_name) list_path = self.__alias_helper.get_wlst_list_path(location) existing_names = self.__wlst_helper.get_existing_object_list(list_path) self.__logger.exiting(class_name=self._class_name, method_name=_method_name, result=existing_names) return existing_names # # methods for merging existing values # def __merge_existing_items(self, items, existing_value): """ Merge the specified items with the items represented by existing value, and return the result. :param items: the attribute name :param existing_value: the value representing the existing items (may be a string or list) :return: the merged list of items :raises BundleAwareException of the specified type: if the WLDF Action/Notification is not found """ _method_name = '__merge_existing_items' self.__logger.entering(str(items), str(existing_value), class_name=self._class_name, method_name=_method_name) existing_items = TypeUtils.convertToType(List, existing_value) # type: list of str no_existing_items = (existing_items is None) or (len(existing_items) == 0) if no_existing_items: result = items else: result = list(Set(items).union(Set(existing_items))) return result
class PrepareModel: """ This is the main driver for the caller. It compares two model files whether they are json or yaml format. """ def __init__(self, model_files, model_context, logger, output_dir=None): self.model_files = model_files self.output_dir = output_dir self.model_context = model_context self._aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE) self._alias_helper = AliasHelper(self._aliases, logger, ExceptionType.COMPARE) self._logger = logger self._name_tokens_location = LocationContext() self._name_tokens_location.add_name_token('DOMAIN', "testdomain") self.current_dict = None self.cache = OrderedDict() self.secrets_to_generate = sets.Set() def __walk_model_section(self, model_section_key, model_dict, valid_section_folders): _method_name = '__validate_model_section' if model_section_key not in model_dict.keys(): return # only specific top-level sections have attributes attribute_location = self._alias_helper.get_model_section_attribute_location( model_section_key) valid_attr_infos = [] path_tokens_attr_keys = [] if attribute_location is not None: valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types( attribute_location) path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names( attribute_location) model_section_dict = model_dict[model_section_key] for section_dict_key, section_dict_value in model_section_dict.iteritems( ): # section_dict_key is either the name of a folder in the # section, or the name of an attribute in the section. validation_location = LocationContext() model_folder_path = model_section_key + ":/" if section_dict_key in valid_attr_infos: # section_dict_key is the name of an attribute in the section self.__walk_attribute(section_dict_key, section_dict_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, attribute_location) elif section_dict_key in valid_section_folders: # section_dict_key is a folder under the model section # Append section_dict_key to location context validation_location.append_location(section_dict_key) # Call self.__validate_section_folder() passing in section_dict_value as the model_node to process self.__walk_section_folder(section_dict_value, validation_location) def __walk_section_folder(self, model_node, validation_location): _method_name = '__validate_section_folder' model_folder_path = self._alias_helper.get_model_folder_path( validation_location) if self._alias_helper.supports_multiple_mbean_instances( validation_location): for name in model_node: expanded_name = name new_location = LocationContext(validation_location) name_token = self._alias_helper.get_name_token(new_location) if name_token is not None: new_location.add_name_token(name_token, expanded_name) value_dict = model_node[name] self.__walk_model_node(value_dict, new_location) elif self._alias_helper.requires_artificial_type_subfolder_handling( validation_location): for name in model_node: expanded_name = name new_location = LocationContext(validation_location) name_token = self._alias_helper.get_name_token(new_location) if name_token is not None: new_location.add_name_token(name_token, expanded_name) value_dict = model_node[name] self.__walk_model_node(value_dict, new_location) else: name_token = self._alias_helper.get_name_token(validation_location) if name_token is not None: name = self._name_tokens_location.get_name_for_token( name_token) if name is None: name = '%s-0' % name_token validation_location.add_name_token(name_token, name) self.__walk_model_node(model_node, validation_location) def __walk_model_node(self, model_node, validation_location): _method_name = '__process_model_node' valid_folder_keys = self._alias_helper.get_model_subfolder_names( validation_location) valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types( validation_location) model_folder_path = self._alias_helper.get_model_folder_path( validation_location) for key, value in model_node.iteritems(): if key in valid_folder_keys: new_location = LocationContext( validation_location).append_location(key) if self._alias_helper.is_artificial_type_folder(new_location): # key is an ARTIFICIAL_TYPE folder valid_attr_infos = self._alias_helper.get_model_attribute_names_and_types( new_location) self.__walk_attributes(value, valid_attr_infos, new_location) else: self.__walk_section_folder(value, new_location) elif key in valid_attr_infos: # aliases.get_model_attribute_names_and_types(location) filters out # attributes that ARE NOT valid in the wlst_version being used, so if # we're in this section of code we know key is a bonafide "valid" attribute valid_data_type = valid_attr_infos[key] if valid_data_type in ['properties']: valid_prop_infos = {} properties = validation_utils.get_properties(value) self.__walk_properties(properties, valid_prop_infos, model_folder_path, validation_location) else: path_tokens_attr_keys = \ self._alias_helper.get_model_uses_path_tokens_attribute_names(validation_location) self.__walk_attribute(key, value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location) def __walk_attributes(self, attributes_dict, valid_attr_infos, validation_location): _method_name = '__validate_attributes' path_tokens_attr_keys = self._alias_helper.get_model_uses_path_tokens_attribute_names( validation_location) model_folder_path = self._alias_helper.get_model_folder_path( validation_location) for attribute_name, attribute_value in attributes_dict.iteritems(): self.__walk_attribute(attribute_name, attribute_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location) def __walk_attribute(self, attribute_name, attribute_value, valid_attr_infos, path_tokens_attr_keys, model_folder_path, validation_location): _method_name = '__walk_attribute' if attribute_name in valid_attr_infos: expected_data_type = valid_attr_infos[attribute_name] if (expected_data_type == 'password') or (attribute_name == ADMIN_USERNAME): self.__substitute_password_with_token(model_folder_path, attribute_name, validation_location) self._logger.exiting(class_name=_class_name, method_name=_method_name) def __walk_properties(self, properties_dict, valid_prop_infos, model_folder_path, validation_location): _method_name = '__walk_properties' for property_name, property_value in properties_dict.iteritems(): valid_prop_infos[ property_name] = validation_utils.get_python_data_type( property_value) self.__walk_property(property_name, property_value, valid_prop_infos, model_folder_path, validation_location) def __walk_property(self, property_name, property_value, valid_prop_infos, model_folder_path, validation_location): _method_name = '__walk_property' self._logger.entering(property_name, property_value, str(valid_prop_infos), model_folder_path, class_name=_class_name, method_name=_method_name) if property_name in valid_prop_infos: expected_data_type = valid_prop_infos[property_name] if expected_data_type == 'password': self.__substitute_password_with_token(model_folder_path, property_name, validation_location) def __substitute_password_with_token(self, model_path, attribute_name, validation_location): """ Add the secret for the specified attribute to the cache. If the target specifies credentials_method: secrets, substitute the secret token into the model. :param model_path: text representation of the model path :param attribute_name: the name of the attribute or (property) :param validation_location: the model location """ model_path_tokens = model_path.split('/') tokens_length = len(model_path_tokens) variable_name = variable_injector_functions.format_variable_name( validation_location, attribute_name, self._aliases) if tokens_length > 1: credentials_method = self.model_context.get_target_configuration( ).get_credentials_method() # by default, don't do any assignment to attribute model_value = None # use attribute name for admin password if model_path_tokens[0] == 'domainInfo:' and model_path_tokens[ 1] == '': cache_key = attribute_name else: cache_key = variable_name # for normal secrets, assign the secret name to the attribute if credentials_method == SECRETS_METHOD: model_value = target_configuration_helper.format_as_secret_token( cache_key) self.cache[cache_key] = '' # for config override secrets, assign a placeholder password to the attribute. # config overrides will be used to override the value in the target domain. if credentials_method == CONFIG_OVERRIDES_SECRETS_METHOD: model_value = PASSWORD_PLACEHOLDER self.cache[cache_key] = '' if model_value is not None: p_dict = self.current_dict for index in range(0, len(model_path_tokens)): token = model_path_tokens[index] if token == '': break if token[-1] == ':': token = token[:-1] p_dict = p_dict[token] p_dict[attribute_name] = model_value def walk(self): """ Replace password attributes in each model file with secret tokens, and write each model. Generate a script to create the required secrets. Create any additional output specified for the target environment. """ _method_name = "walk" model_file_name = None try: model_file_list = self.model_files.split(',') for model_file in model_file_list: self.cache.clear() if os.path.splitext(model_file)[1].lower() == ".yaml": model_file_name = model_file FileToPython(model_file_name, True).parse() aliases = Aliases(model_context=self.model_context, wlst_mode=WlstModes.OFFLINE) validator = Validator(self.model_context, aliases, wlst_mode=WlstModes.OFFLINE) # Just merge and validate but without substitution model_dictionary = cla_helper.merge_model_files( model_file_name, None) variable_file = self.model_context.get_variable_file() if not os.path.exists(variable_file): variable_file = None return_code = validator.validate_in_tool_mode( model_dictionary, variables_file_name=variable_file, archive_file_name=None) if return_code == Validator.ReturnCode.STOP: self._logger.severe('WLSDPLY-05705', model_file_name) return VALIDATION_FAIL self.current_dict = model_dictionary self.__walk_model_section( model.get_model_domain_info_key(), self.current_dict, aliases.get_model_section_top_level_folder_names( DOMAIN_INFO)) self.__walk_model_section( model.get_model_topology_key(), self.current_dict, aliases.get_model_topology_top_level_folder_names()) self.__walk_model_section( model.get_model_resources_key(), self.current_dict, aliases.get_model_resources_top_level_folder_names()) self.current_dict = self._apply_filter_and_inject_variable( self.current_dict, self.model_context, validator) file_name = os.path.join(self.output_dir, os.path.basename(model_file_name)) fos = JFileOutputStream(file_name, False) writer = JPrintWriter(fos, True) pty = PythonToYaml(self.current_dict) pty._write_dictionary_to_yaml_file(self.current_dict, writer) writer.close() self.cache.clear() for key in self.secrets_to_generate: self.cache[key] = '' # use a merged, substituted, filtered model to get domain name and create additional target output. full_model_dictionary = cla_helper.load_model( _program_name, self.model_context, self._alias_helper, "discover", WlstModes.OFFLINE) target_configuration_helper.generate_k8s_script( self.model_context, self.cache, full_model_dictionary) # create any additional outputs from full model dictionary target_configuration_helper.create_additional_output( Model(full_model_dictionary), self.model_context, self._alias_helper, ExceptionType.VALIDATE) except ValidateException, te: self._logger.severe('WLSDPLY-20009', _program_name, model_file_name, te.getLocalizedMessage(), error=te, class_name=_class_name, method_name=_method_name) ex = exception_helper.create_compare_exception( te.getLocalizedMessage(), error=te) self._logger.throwing(ex, class_name=_class_name, method_name=_method_name) return VALIDATION_FAIL except VariableException, ve: self._logger.severe('WLSDPLY-20009', _program_name, model_file_name, ve.getLocalizedMessage(), error=ve, class_name=_class_name, method_name=_method_name) ex = exception_helper.create_compare_exception( ve.getLocalizedMessage(), error=ve) self._logger.throwing(ex, class_name=_class_name, method_name=_method_name) return VALIDATION_FAIL