def __resolve_paths(self):
"""
Resolve any tokens in the template paths.
:raises: CreateException: if an error occurs resolving the paths
"""
_method_name = '__resolve_paths'
if not self._paths_resolved:
if self._model_context is None:
ex = exception_helper.create_create_exception('WLSDPLY-12302')
self._logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
if 'baseTemplate' in self._domain_typedef:
self._domain_typedef['baseTemplate'] = \
self._model_context.replace_token_string(self._domain_typedef['baseTemplate'])
else:
ex = exception_helper.create_create_exception(
'WLSDPLY-12303', self._domain_type,
self._domain_typedef_filename, self._version_typedef_name)
self._logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
if 'extensionTemplates' in self._domain_typedef:
extension_templates = self._domain_typedef[
'extensionTemplates']
resolved_templates = []
for extension_template in extension_templates:
resolved_templates.append(
self._model_context.replace_token_string(
extension_template))
self._domain_typedef['extensionTemplates'] = resolved_templates
else:
self._domain_typedef['extensionTemplates'] = []
if 'customExtensionTemplates' in self._domain_typedef:
extension_templates = self._domain_typedef[
'customExtensionTemplates']
resolved_templates = []
for extension_template in extension_templates:
resolved_templates.append(
self._model_context.replace_token_string(
extension_template))
self._domain_typedef[
'customExtensionTemplates'] = resolved_templates
else:
self._domain_typedef['customExtensionTemplates'] = []
if 'serverGroupsToTarget' not in self._domain_typedef:
self._domain_typedef['serverGroupsToTarget'] = []
if 'rcuSchemas' not in self._domain_typedef:
self._domain_typedef['rcuSchemas'] = []
self._paths_resolved = True
return
def __get_version_typedef(self):
"""
Get the domain typedef that matches the current WLS version.
:return: the version-specific domain typedef
:raises: CreateException: if an error occurs resolving the paths
"""
_method_name = '__get_version_typedef'
if 'versions' not in self._domain_typedefs_dict:
ex = exception_helper.create_create_exception('WLSDPLY-12304', self._domain_type,
self._domain_typedef_filename)
self._logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
elif 'definitions' not in self._domain_typedefs_dict:
ex = exception_helper.create_create_exception('WLSDPLY-12305', self._domain_type,
self._domain_typedef_filename)
self._logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
self._version_typedef_name = self.__match_version_typedef(self._domain_typedefs_dict['versions'])
if self._version_typedef_name in self._domain_typedefs_dict['definitions']:
result = self._domain_typedefs_dict['definitions'][self._version_typedef_name]
else:
ex = exception_helper.create_create_exception('WLSDPLY-12306', self._domain_type,
self._domain_typedef_filename, self._version_typedef_name)
self._logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
return result
def __match_version_typedef(self, versions_dict):
"""
Match the version typedef to the current WLS version
:param versions_dict: the versions dictionary
:return: the matching version typedef
:raises: CreateException: if an error occurs resolving the paths
"""
_method_name = '__match_version_typedef'
self._logger.entering(versions_dict,
class_name=self.__class_name,
method_name=_method_name)
if len(versions_dict) == 0:
ex = exception_helper.create_create_exception(
'WLSDPLY-12307', self._domain_type,
self._domain_typedef_filename)
self._logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
wls_helper = WebLogicHelper(self._logger)
wls_version = wls_helper.get_actual_weblogic_version()
self._logger.fine('WLSDPLY-12310',
wls_version,
class_name=self.__class_name,
method_name=_method_name)
result = None
if wls_version in versions_dict:
result = versions_dict[wls_version]
else:
new_version = wls_helper.get_next_higher_order_version_number(
wls_version)
while new_version is not None:
if new_version in versions_dict:
result = versions_dict[new_version]
self._logger.finer('WLSDPLY-12308',
self._domain_type,
self._domain_typedef_filename,
new_version,
wls_version,
class_name=self.__class_name,
method_name=_method_name)
break
else:
new_version = wls_helper.get_next_higher_order_version_number(
new_version)
if result is None:
ex = exception_helper.create_create_exception(
'WLSDPLY-12309', self._domain_type,
self._domain_typedef_filename, wls_version)
self._logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
self._logger.exiting(self.__class_name, _method_name, result)
return result
def _set_attribute(self, location, model_name, model_value, uses_path_tokens_names, masked=False):
"""
Set the specified attribute at the specified location to the specified value.
:param location: the location
:param model_name: the model attribute name
:param model_value: the model attribute value
:param: uses_path_token_names: the list of model attribute names that use file system path tokens
:param masked: whether or not to mask the attribute value in the log
:raises: CreateException: if an error occurs
"""
_method_name = '_set_attribute'
if model_name in uses_path_tokens_names and WLSDeployArchive.isPathIntoArchive(model_value):
if self.archive_helper is not None:
if self.archive_helper.contains_file(model_value):
#
# We cannot extract the files until the domain directory exists
# so add them to the list so that they can be extracted after
# domain creation completes.
#
self.files_to_extract_from_archive.append(model_value)
else:
path = self.alias_helper.get_model_folder_path(location)
archive_file_name = self.model_context.get_archive_file_name
ex = exception_helper.create_create_exception('WLSDPLY-12121', model_name, path,
model_value, archive_file_name)
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
else:
path = self.alias_helper.get_model_folder_path(location)
ex = exception_helper.create_create_exception('WLSDPLY-12122', model_name, path, model_value)
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
wlst_name, wlst_value = self.alias_helper.get_wlst_attribute_name_and_value(location, model_name, model_value)
if wlst_name is None:
self.logger.info('WLSDPLY-12106', model_name, self.alias_helper.get_model_folder_path(location),
class_name=self.__class_name, method_name=_method_name)
elif wlst_value is None:
logged_value = model_value
if masked:
logged_value = '<masked>'
self.logger.info('WLSDPLY-12107', model_name, logged_value,
self.alias_helper.get_model_folder_path(location),
class_name=self.__class_name, method_name=_method_name)
else:
logged_value = wlst_value
if masked:
logged_value = '<masked>'
self.logger.finest('WLSDPLY-12115', wlst_name, logged_value,
class_name=self.__class_name, method_name=_method_name)
self.wlst_helper.set(wlst_name, wlst_value, masked=masked)
return
def _extract_archive_files(self, location, model_name, model_value):
"""
Extract any archive files associated with the specified model attribute value.
The attribute has already been determined to use path tokens.
:param location: the location of the attribute
:param model_name: the model attribute name
:param model_value: the model attribute value
:raises: CreateException: if an error occurs
"""
_method_name = '_extract_archive_files'
# model value should be a list, comma-delimited string, or string
model_paths = model_value
if isinstance(model_value, str):
model_paths = model_value.split(',')
for model_path in model_paths:
model_path = model_path.strip()
# check for path starting with "wlsdeploy/".
# skip classpath libraries, they are extracted elsewhere.
if WLSDeployArchive.isPathIntoArchive(
model_path
) and not WLSDeployArchive.isClasspathEntry(model_path):
if self.archive_helper is not None:
if self.archive_helper.contains_file(model_path):
#
# We cannot extract the files until the domain directory exists
# so add them to the list so that they can be extracted after
# domain creation completes.
#
self.files_to_extract_from_archive.append(model_path)
else:
path = self.alias_helper.get_model_folder_path(
location)
archive_file_name = self.model_context.get_archive_file_name(
)
ex = exception_helper.create_create_exception(
'WLSDPLY-12121', model_name, path, model_path,
archive_file_name)
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
else:
path = self.alias_helper.get_model_folder_path(location)
ex = exception_helper.create_create_exception(
'WLSDPLY-12122', model_name, path, model_path)
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
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.aliases.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.aliases.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.aliases.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.aliases.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 install_domain_libraries(self):
"""
Extract the domain libraries listed in the model, if any, to the <DOMAIN_HOME>/lib directory.
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = 'install_domain_libraries'
self.logger.entering(self.domain_home, class_name=self.__class_name, method_name=_method_name)
domain_info_dict = self.model.get_model_domain_info()
if DOMAIN_LIBRARIES not in domain_info_dict or len(domain_info_dict[DOMAIN_LIBRARIES]) == 0:
self.logger.info('WLSDPLY-12213', class_name=self.__class_name, method_name=_method_name)
elif DOMAIN_LIBRARIES in domain_info_dict:
domain_libs = dictionary_utils.get_dictionary_element(domain_info_dict, DOMAIN_LIBRARIES)
if self.archive_helper is None:
ex = exception_helper.create_create_exception('WLSDPLY-12214', domain_libs)
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
for domain_lib in domain_libs:
if WLSDeployArchive.isPathIntoArchive(domain_lib):
self.logger.info('WLSDPLY-12215', domain_lib, self.domain_home,
class_name=self.__class_name, method_name=_method_name)
self.archive_helper.extract_domain_library(domain_lib)
else:
self.logger.info('WLSDPLY-12235', domain_lib, self.domain_home,
class_name=self.__class_name, method_name=_method_name)
self._copy_domain_library(domain_lib)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
def __run_rcu(self):
"""
The method that runs RCU to drop and then create the schemas.
:raises CreateException: if running rcu fails
"""
_method_name = '__run_rcu'
self.logger.entering(class_name=self.__class_name, method_name=_method_name)
if not self.model_context.is_run_rcu():
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
elif not self.wls_helper.is_weblogic_version_or_above('12.1.2'):
ex = exception_helper.create_create_exception('WLSDPLY-12201', self.__program_name,
self.wls_helper.get_actual_weblogic_version())
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
rcu_schemas = self._domain_typedef.get_rcu_schemas()
if len(rcu_schemas) == 0:
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
domain_type = self.model_context.get_domain_type()
oracle_home = self.model_context.get_oracle_home()
java_home = self.model_context.get_java_home()
rcu_db = self.model_context.get_rcu_database()
rcu_prefix = self.model_context.get_rcu_prefix()
rcu_sys_pass = self.model_context.get_rcu_sys_pass()
rcu_schema_pass = self.model_context.get_rcu_schema_pass()
runner = RCURunner(domain_type, oracle_home, java_home, rcu_db, rcu_prefix, rcu_schemas)
runner.runRcu(rcu_sys_pass, rcu_schema_pass)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
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
def __set_admin_password(self):
"""
Set the administrative user's password.
:raises: CreateException: if an error occurs
"""
_method_name = '__set_admin_password'
if ADMIN_PASSWORD in self._domain_info:
admin_password = self._domain_info[ADMIN_PASSWORD]
admin_username = self.wls_helper.get_default_admin_username()
if ADMIN_USERNAME in self._domain_info:
admin_username = self._domain_info[ADMIN_USERNAME]
location = LocationContext().append_location(SECURITY)
token_name = self.alias_helper.get_name_token(location)
if token_name is not None:
location.add_name_token(token_name, self._domain_name)
location.append_location(USER)
token_name = self.alias_helper.get_name_token(location)
if token_name is not None:
location.add_name_token(
token_name, self.wls_helper.get_default_admin_username())
admin_user_path = self.alias_helper.get_wlst_attributes_path(
location)
self.wlst_helper.cd(admin_user_path)
wlst_name, wlst_value = \
self.alias_helper.get_wlst_attribute_name_and_value(location, NAME, admin_username)
self.wlst_helper.set_if_needed(wlst_name, wlst_value, NAME,
admin_username)
wlst_name, wlst_value = \
self.alias_helper.get_wlst_attribute_name_and_value(location, PASSWORD, admin_password, masked=True)
self.wlst_helper.set_if_needed(wlst_name,
wlst_value,
PASSWORD,
'<masked>',
masked=True)
else:
ex = exception_helper.create_create_exception(
'WLSDPLY-12228', 'AdminPassword',
model_helper.get_model_domain_info_key())
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
return
def _copy_domain_library(self, domain_lib):
"""
Copy the specified domain library to the domain's lib directory.
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = '_copy_domain_library'
source_path = File(domain_lib).getAbsolutePath()
target_dir = File(self.domain_home, 'lib').getPath()
try:
copy(str(source_path), str(target_dir))
except IOError:
ex = exception_helper.create_create_exception('WLSDPLY-12234', source_path, target_dir)
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
def install_domain_scripts(self):
"""
Extract the scripts from domain bin listed in the model, if any, to the <DOMAIN_HOME>/bin directory.
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = 'install_domain_scripts'
self.logger.entering(self.domain_home,
class_name=self.__class_name,
method_name=_method_name)
domain_info_dict = self.model.get_model_domain_info()
if DOMAIN_SCRIPTS not in domain_info_dict or len(
domain_info_dict[DOMAIN_SCRIPTS]) == 0:
self.logger.info('WLSDPLY-12241',
class_name=self.__class_name,
method_name=_method_name)
elif DOMAIN_SCRIPTS in domain_info_dict:
domain_scripts = dictionary_utils.get_dictionary_element(
domain_info_dict, DOMAIN_SCRIPTS)
if self.archive_helper is None:
ex = exception_helper.create_create_exception(
'WLSDPLY-12250', domain_scripts)
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
for domain_script in domain_scripts:
if WLSDeployArchive.isPathIntoArchive(domain_script):
self.logger.info('WLSDPLY-12251',
domain_script,
self.domain_home,
class_name=self.__class_name,
method_name=_method_name)
self.archive_helper.extract_domain_bin_script(
domain_script)
else:
self.logger.info('WLSDPLY-12252',
domain_script,
self.domain_home,
class_name=self.__class_name,
method_name=_method_name)
self._copy_domain_bin(domain_script)
self.logger.exiting(class_name=self.__class_name,
method_name=_method_name)
return
def __fail_mt_1221_domain_creation(self):
"""
Abort create if domain contains MT artifacts that cannot be created in the version of WLST offline being used.
:raises: CreateException: if the MT domain cannot be provision on the specified version of WLST offline
"""
_method_name = '__fail_mt_1221_domain_creation'
if self.wls_helper.is_mt_offline_provisioning_supported():
return
resources_dict = self.model.get_model_resources()
if (not dictionary_utils.is_empty_dictionary_element(self._topology, VIRTUAL_TARGET)) or \
(not dictionary_utils.is_empty_dictionary_element(resources_dict, RESOURCE_GROUP_TEMPLATE)) or \
(not dictionary_utils.is_empty_dictionary_element(resources_dict, RESOURCE_GROUP)) or \
(not dictionary_utils.is_empty_dictionary_element(resources_dict, PARTITION)):
ex = exception_helper.create_create_exception('WLSDPLY-12202', self.wls_helper.wl_version)
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
return
def _create_subfolders(self, location, model_nodes):
"""
Create the child MBean folders at the specified location.
:param location: the location
:param model_nodes: the model dictionary
:raises: CreateException: if an error occurs
"""
_method_name = '_create_subfolders'
self.logger.entering(location.get_folder_path(), class_name=self.__class_name, method_name=_method_name)
model_subfolder_names = self.alias_helper.get_model_subfolder_names(location)
for key in model_nodes:
if key in model_subfolder_names:
subfolder_nodes = model_nodes[key]
sub_location = LocationContext(location).append_location(key)
# both create and update are merge to model so will process a subfolder with an empty node
if self.alias_helper.requires_artificial_type_subfolder_handling(sub_location):
self.logger.finest('WLSDPLY-12116', key, str(sub_location), subfolder_nodes,
class_name=self.__class_name, method_name=_method_name)
self._create_security_provider_mbeans(key, subfolder_nodes, location, True)
elif len(subfolder_nodes) != 0:
if self.alias_helper.supports_multiple_mbean_instances(sub_location):
self.logger.finest('WLSDPLY-12109', key, str(sub_location), subfolder_nodes,
class_name=self.__class_name, method_name=_method_name)
self._create_named_mbeans(key, subfolder_nodes, location)
elif self.alias_helper.is_artificial_type_folder(sub_location):
ex = exception_helper.create_create_exception('WLSDPLY-12120', str(sub_location),
key, str(location))
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
else:
self.logger.finest('WLSDPLY-12110', key, str(sub_location), subfolder_nodes,
class_name=self.__class_name, method_name=_method_name)
self._create_mbean(key, subfolder_nodes, location)
self.logger.exiting(class_name=self.__class_name, method_name=_method_name)
return
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.aliases.get_model_folder_path(location),
error=ae)
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
else:
ex = exception_helper.create_create_exception(
'WLSDPLY-12105', model_key,
self.aliases.get_model_folder_path(location))
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
return
def _set_attribute(self,
location,
model_name,
model_value,
uses_path_tokens_names,
masked=False):
"""
Set the specified attribute at the specified location to the specified value.
def __init__(self, model_dictionary, model_context, aliases):
_method_name = '__init__'
Creator.__init__(self, model_dictionary, model_context, aliases)
# domainInfo section is required to get the admin password, everything else
# is optional and will use the template defaults
if model_helper.get_model_domain_info_key() not in model_dictionary:
ex = exception_helper.create_create_exception(
'WLSDPLY-12200', self.__program_name,
model_helper.get_model_domain_info_key(),
self.model_context.get_model_file())
self.logger.throwing(ex,
class_name=self.__class_name,
method_name=_method_name)
raise ex
self.topology_helper = TopologyHelper(self.aliases,
ExceptionType.CREATE,
self.logger)
self.security_provider_creator = SecurityProviderCreator(
model_dictionary, model_context, aliases, ExceptionType.CREATE,
self.logger)
self._domain_typedef = self.model_context.get_domain_typedef()
self._topology = self.model.get_model_topology()
self._domain_info = self.model.get_model_domain_info()
if DOMAIN_NAME in self._topology:
self._domain_name = self._topology[DOMAIN_NAME]
else:
self._domain_name = DEFAULT_WLS_DOMAIN_NAME
# if domain home specified on command line, set it here, otherwise append domain name to domain parent
model_domain_home = self.model_context.get_domain_home()
if model_domain_home:
self._domain_home = model_domain_home
else:
self._domain_home = os.path.join(
self.model_context.get_domain_parent_dir(), self._domain_name)
if ADMIN_SERVER_NAME in self._topology:
self._admin_server_name = self._topology[ADMIN_SERVER_NAME]
else:
self._admin_server_name = DEFAULT_ADMIN_SERVER_NAME
self.__default_domain_name = None
self.__default_admin_server_name = None
self.__default_security_realm_name = None
archive_file_name = self.model_context.get_archive_file_name()
if archive_file_name is not None:
self.archive_helper = ArchiveHelper(
archive_file_name, self._domain_home, self.logger,
exception_helper.ExceptionType.CREATE)
self.library_helper = LibraryHelper(self.model, self.model_context,
self.aliases, self._domain_home,
ExceptionType.CREATE, self.logger)
self.target_helper = TargetHelper(self.model, self.model_context,
self.aliases, ExceptionType.CREATE,
self.logger)
#
# This list gets modified as the domain is being created so do use this list for anything else...
#
self.__topology_folder_list = self.alias_helper.get_model_topology_top_level_folder_names(
)
return
def __init__(self, model_dictionary, model_context, aliases):
_method_name = '__init__'
Creator.__init__(self, model_dictionary, model_context, aliases)
# domainInfo section is required to get the admin password, everything else
# is optional and will use the template defaults
if model_helper.get_model_domain_info_key() not in model_dictionary:
ex = exception_helper.create_create_exception('WLSDPLY-12200', self.__program_name,
model_helper.get_model_domain_info_key(),
self.model_context.get_model_file())
self.logger.throwing(ex, class_name=self.__class_name, method_name=_method_name)
raise ex
self.topology_helper = TopologyHelper(self.aliases, ExceptionType.CREATE, self.logger)
self.security_provider_creator = SecurityProviderCreator(model_dictionary, model_context, aliases,
ExceptionType.CREATE, self.logger)
self._domain_typedef = self.model_context.get_domain_typedef()
self._topology = self.model.get_model_topology()
self._domain_info = self.model.get_model_domain_info()
if DOMAIN_NAME in self._topology:
self._domain_name = self._topology[DOMAIN_NAME]
else:
self._domain_name = DEFAULT_WLS_DOMAIN_NAME
self._domain_home = os.path.join(self.model_context.get_domain_parent_dir(), self._domain_name)
if ADMIN_SERVER_NAME in self._topology:
self._admin_server_name = self._topology[ADMIN_SERVER_NAME]
else:
self._admin_server_name = DEFAULT_ADMIN_SERVER_NAME
self.__default_domain_name = None
self.__default_admin_server_name = None
self.__default_security_realm_name = None
archive_file_name = self.model_context.get_archive_file_name()
if archive_file_name is not None:
self.archive_helper = ArchiveHelper(archive_file_name, self._domain_home, self.logger,
exception_helper.ExceptionType.CREATE)
self.library_helper = LibraryHelper(self.model, self.model_context, self.aliases, self._domain_home,
ExceptionType.CREATE, self.logger)
self.target_helper = TargetHelper(self.model, self.model_context, self.aliases, ExceptionType.CREATE,
self.logger)
#
# Creating domains with the wls.jar template is busted for pre-12.1.2 domains with regards to the
# names of the default authentication providers (both the DefaultAuthenticator and the
# DefaultIdentityAsserter names are 'Provider', making it impossible to work with in WLST. If
# the WLS version is earlier than fix this as part of domain creation...
#
self.__fix_default_authentication_provider_names = \
self.wls_helper.do_default_authentication_provider_names_need_fixing()
#
# This list gets modified as the domain is being created so do use this list for anything else...
#
self.__topology_folder_list = self.alias_helper.get_model_topology_top_level_folder_names()
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
