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 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: