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
