def __init__(self,
program_name,
model,
model_context,
version=None,
variable_dictionary=None):
"""
Construct an instance of the injector with the model and information used by the injector.
:param program_name: name of the calling tool
:param model: to be updated with variables
:param model_context: context with command line information
:param version: of model if model context is not provided
"""
self.__program_name = program_name
self.__original = copy.deepcopy(model)
self.__model = model
self.__model_context = model_context
if self.__model_context:
self.__wlst_mode = self.__model_context.get_target_wlst_mode()
else:
self.__wlst_mode = WlstModes.OFFLINE
self.__section_keys = model_sections.get_model_top_level_keys()
self.__section_keys.remove(model_sections.get_model_domain_info_key())
if version:
self.__aliases = Aliases(model_context,
wlst_mode=self.__wlst_mode,
wls_version=version)
else:
self.__aliases = Aliases(model_context)
self.__variable_dictionary = variable_dictionary
def __init__(self,
model_context,
base_location,
wlst_mode,
aliases=None,
credential_injector=None):
"""
:param model_context: context about the model for this instance of discover domain
:param base_location: to look for common weblogic resources. By default this is the global path or '/'
:param wlst_mode: offline or online
:param aliases: optional, aliases object to use
:param credential_injector: optional, injector to collect credentials
"""
self._model_context = model_context
self._base_location = base_location
self._wlst_mode = wlst_mode
if aliases:
self._aliases = aliases
else:
self._aliases = Aliases(self._model_context,
wlst_mode=self._wlst_mode,
exception_type=ExceptionType.DISCOVER)
self._credential_injector = credential_injector
self._att_handler_map = OrderedDict()
self._custom_folder = CustomFolderHelper(self._aliases, _logger,
self._model_context,
ExceptionType.DISCOVER,
self._credential_injector)
self._weblogic_helper = WebLogicHelper(_logger)
self._wlst_helper = WlstHelper(ExceptionType.DISCOVER)
self._mbean_utils = MBeanUtils(self._model_context, self._aliases,
ExceptionType.DISCOVER)
self._wls_version = self._weblogic_helper.get_actual_weblogic_version()
def _is_alias_folder(self, path):
"""
Check if the delimited path is a folder or attribute
:param path: '|' delimited path
:return: true if it is a folder otherwise false
"""
debug("DEBUG: Entering is_alias_folder %s", path)
path_tokens = path.split(PATH_TOKEN)
model_context = ModelContext("test", {})
aliases = Aliases(model_context=model_context,
wlst_mode=WlstModes.OFFLINE)
location = LocationContext()
last_token = path_tokens[-1]
alias_helper = AliasHelper(aliases, __logger, ExceptionType.COMPARE)
found = True
name_token_next = False
for path_token in path_tokens[1:]:
if name_token_next:
token_name = aliases.get_name_token(location)
location.add_name_token(token_name, path_token)
name_token_next = False
else:
location.append_location(path_token)
if last_token == path_token:
break
name_token_next = alias_helper.supports_multiple_mbean_instances(
location)
attrib_names = alias_helper.get_model_attribute_names(location)
if last_token in attrib_names:
found = False
debug("DEBUG: is_alias_folder %s %s", path, found)
return found
class AliasEncryptedModelTestCase(unittest.TestCase):
"""
Test cases for a the -use_encryption feature.
"""
_logger = PlatformLogger('wlsdeploy.aliases')
_wls_version = '12.2.1.3'
_wlst_password_name = "Password"
_wlst_password_encrypted_name = "PasswordEncrypted"
_passphrase = 'RE a drop of golden sun'
_password = '******'
_encrypted_password = '******'
def setUp(self):
# construct aliases as if the -use_encryption and -passphrase switches were used
model_context = ModelContext("test", {CommandLineArgUtil.USE_ENCRYPTION_SWITCH: 'true',
CommandLineArgUtil.PASSPHRASE_SWITCH: self._passphrase})
self.aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE, wls_version=self._wls_version)
self.online_aliases = Aliases(model_context, wlst_mode=WlstModes.ONLINE, wls_version=self._wls_version)
self.location = LocationContext()
self.location.append_location(JDBC_SYSTEM_RESOURCE)
self.location.add_name_token(self.aliases.get_name_token(self.location), "Mine")
self.location.append_location(JDBC_RESOURCE)
self.location.append_location(JDBC_DRIVER_PARAMS)
def testOfflineWlstNames(self):
# Using offline WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute, regardless of whether the password is encrypted. The password value should be plain text.
# using encrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._password)
# using unencrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._password)
def testOnlineWlstNames(self):
# Using online WLST, the PasswordEncrypted model attribute should always translate to the Password WLST
# attribute, and the value should translate to the unencrypted value.
# using encrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED,
self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_name)
self.assertEqual(wlst_value, self._password)
# using unencrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_name)
self.assertEqual(wlst_value, self._password)
def setUp(self):
model_context = ModelContext("test", {})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = aliases_test.get_jdbc_driver_params_location(
"Mine", self.aliases)
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,
exception_type=ExceptionType.COMPARE)
self._logger = logger
self._name_tokens_location = LocationContext()
self._name_tokens_location.add_name_token('DOMAIN', "testdomain")
self.current_dict = None
self.credential_injector = CredentialInjector(_program_name, None, model_context)
def testAttributeNames(self):
model_context = ModelContext("test", { })
aliases = Aliases(model_context=model_context, wlst_mode=WlstModes.OFFLINE, wls_version=self.wls_version)
location = LocationContext()
self._check_folder('Domain', location, aliases)
for folder_name in aliases.get_model_top_level_folder_names():
location = LocationContext()
location.append_location(folder_name)
self._check_folder(folder_name, location, aliases)
def setUp(self):
model_context = ModelContext("test", {CommandLineArgUtil.USE_ENCRYPTION_SWITCH: 'true',
CommandLineArgUtil.PASSPHRASE_SWITCH: self._passphrase})
self.aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE, wls_version=self._wls_version)
self.online_aliases = Aliases(model_context, wlst_mode=WlstModes.ONLINE, wls_version=self._wls_version)
self.location = LocationContext()
self.location.append_location(JDBC_SYSTEM_RESOURCE)
self.location.add_name_token(self.aliases.get_name_token(self.location), "Mine")
self.location.append_location(JDBC_RESOURCE)
self.location.append_location(JDBC_DRIVER_PARAMS)
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()
class VariableInjectorFunctionsTests(unittest.TestCase):
"""
Test the variable injector functions methods.
"""
wls_version = '12.2.1.3'
attribute_name = 'Notes'
def setUp(self):
model_context = ModelContext("test", {})
self.aliases = Aliases(model_context)
self.location = LocationContext().append_location(MACHINE)
self.name_token = self.aliases.get_name_token(self.location)
self.short_name = self.aliases.get_folder_short_name(self.location)
def testFormatVariableName(self):
"""
Verify that names from location are converted to valid variable names.
"""
# spaces in model name
self._check_name('My Machine', 'My-Machine')
# parenthesis can be in model name
self._check_name('ohMy-(datasource)', 'ohMy--datasource-')
# versioned library names may be model names
self._check_name(
'Lib.oracle.wsm.idmrest.sharedlib#[email protected]',
'Lib.oracle.wsm.idmrest.sharedlib-1.0-12.2.1.3.Target')
def _check_name(self, name, expected_key):
"""
Verify that the specified name is converted to match the expected key.
A machine location is created with the supplied name and converted to a variable name.
An expected value is constructed using the expected key and known parameters.
:param name: the name to be converted
:param expected_key: the expected variable key
"""
self.location.add_name_token(self.name_token, name)
variable_name = variable_injector_functions.format_variable_name(
self.location, self.attribute_name, self.aliases)
# verify that a property built with this value will parse correctly
property_text = '@@PROP:%s@@' % variable_name
matches = variables._property_pattern.findall(property_text)
self.assertEqual(1, len(matches),
"Property %s should parse correctly" % property_text)
expected_name = "%s.%s.%s" % (self.short_name, expected_key,
self.attribute_name)
self.assertEqual(expected_name, variable_name)
def setUp(self):
model_context = ModelContext("test", {})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = LocationContext()
self.location.append_location(JDBC_SYSTEM_RESOURCE)
self.location.add_name_token(
self.aliases.get_name_token(self.location), "Mine")
self.location.append_location(JDBC_RESOURCE)
self.location.append_location(JDBC_DRIVER_PARAMS)
def print_help(model_path, model_context):
"""
Prints the folders and/or attributes for the specified given model_path,
using control_option to filter what is output
:param model_path: the model path to print help for
:param model_context: the model context, used to determine print options
:return: an exit code
"""
_method_name = 'print_help'
__logger.entering(model_path, class_name=_class_name, method_name=_method_name)
# default to NORMAL
control_option = ModelHelpPrinter.ControlOptions.NORMAL
# determine control option using the model_context
if model_context.get_recursive_control_option():
control_option = ModelHelpPrinter.ControlOptions.RECURSIVE
elif model_context.get_attributes_only_control_option():
control_option = ModelHelpPrinter.ControlOptions.ATTRIBUTES_ONLY
elif model_context.get_folders_only_control_option():
control_option = ModelHelpPrinter.ControlOptions.FOLDERS_ONLY
aliases = Aliases(model_context)
printer = ModelHelpPrinter(aliases, __logger)
printer.print_model_help(model_path, control_option)
__logger.exiting(class_name=_class_name, method_name=_method_name)
return CommandLineArgUtil.PROG_OK_EXIT_CODE
def testPersistModelAfterFilter(self):
"""
Verify filter was run and changes are persisted to model file
"""
# Setup model context arguments
_model_file = self._resources_dir + '/simple-model.yaml'
_archive_file = self._resources_dir + "/SingleAppDomain.zip"
_method_name = 'testPersistModelAfterFilter'
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-model_file': _model_file,
'-archive_file': _archive_file
}
model_context = ModelContext('validate', args_map)
aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE, exception_type=ExceptionType.DEPLOY)
# Load model and invoke filter
model_dictionary = cla_helper.load_model('validateModel', model_context, aliases, "validate", WlstModes.OFFLINE)
# assert the validate filter made modications and was persisted
self.assertEquals('gumby1234', model_dictionary['domainInfo']['AdminPassword'], "Expected validate filter to have changed AdminPassword to 'gumby1234'")
def setUp(self):
# construct aliases as if the -use_encryption and -passphrase switches were used
model_context = ModelContext(
"test", {
CommandLineArgUtil.USE_ENCRYPTION_SWITCH: 'true',
CommandLineArgUtil.PASSPHRASE_SWITCH: self._passphrase
})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = aliases_test.get_jdbc_driver_params_location(
"Mine", self.aliases)
def testDelimitedAttributes(self):
# This test ensures that delimited attributes are always comma-delimited for the model.
# Space-delimited attributes are allowed to bypass this rule.
model_context = ModelContext("test", {})
aliases = Aliases(model_context=model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self.wls_version)
location = LocationContext()
self._check_folder(location, aliases)
for folder_name in aliases.get_model_top_level_folder_names():
location = LocationContext()
location.append_location(folder_name)
self._check_folder(location, aliases)
def __init__(self,
model_context,
base_location,
wlst_mode,
aliases=None,
variable_injector=None):
"""
:param model_context: context about the model for this instance of discover domain
:param base_location: to look for common weblogic resources. By default this is the global path or '/'
"""
self._model_context = model_context
self._base_location = base_location
self._wlst_mode = wlst_mode
if aliases:
self._aliases = aliases
else:
self._aliases = Aliases(self._model_context,
wlst_mode=self._wlst_mode)
self._alias_helper = AliasHelper(self._aliases, _logger,
ExceptionType.DISCOVER)
self._variable_injector = variable_injector
self._att_handler_map = OrderedDict()
self._custom_folder = CustomFolderHelper(self._aliases, _logger,
self._model_context,
ExceptionType.DISCOVER,
self._variable_injector)
self._weblogic_helper = WebLogicHelper(_logger)
self._wlst_helper = WlstHelper(ExceptionType.DISCOVER)
self._mbean_utils = MBeanUtils(self._model_context, self._alias_helper,
ExceptionType.DISCOVER)
self._wls_version = self._weblogic_helper.get_actual_weblogic_version()
def __init__(self, model_context, exception_type, location):
self.__model_context = model_context
self.__exception_type = exception_type
self.__location = location
self.__aliases = Aliases(
self.__model_context,
wlst_mode=self.__model_context.get_target_wlst_mode())
self.__alias_helper = AliasHelper(self.__aliases, _logger,
exception_type)
self.__wlst_helper = WlstHelper(_logger, exception_type)
self.__mbean_instance = None
self.__mbean_name = ''
def setUp(self):
arg_map = dict()
arg_map[CLA.ORACLE_HOME_SWITCH] = '/my/path/to/oracle'
arg_map[CLA.TARGET_MODE_SWITCH] = 'offline'
self._model_context = ModelContext("test", arg_map)
self._aliases = Aliases(model_context=self._model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self._custom_helper = CustomFolderHelper(self._aliases, self._logger,
self._model_context,
ExceptionType.DISCOVER)
return
def _get_model_help(self, path, control_option):
try:
old_out = sys.stdout
sys.stdout = StringIO()
model_context = ModelContext(self._program_name, { })
aliases = Aliases(model_context, WlstModes.OFFLINE, self.wls_version)
printer = ModelHelpPrinter(aliases, self._logger)
printer.print_model_help(path, control_option)
sys.stdout.flush()
text = sys.stdout.getvalue()
sys.stdout = old_out
return text
except CLAException, e:
self.fail(e.getLocalizedMessage())
cla_helper.clean_up_temp_files()
tool_exit.end(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
try:
variables.substitute(model_dictionary, variable_map, model_context)
except VariableException, ex:
__logger.severe('WLSDPLY-20004',
_program_name,
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
method_name=_method_name)
cla_helper.clean_up_temp_files()
tool_exit.end(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
aliases = Aliases(model_context, wlst_mode=__wlst_mode)
validate_model(model_dictionary, model_context, aliases)
if filter_helper.apply_filters(model_dictionary, "deploy"):
# if any filters were applied, re-validate the model
validate_model(model_dictionary, model_context, aliases)
try:
model = Model(model_dictionary)
exit_code = __deploy(model, model_context, aliases)
except DeployException, ex:
__logger.severe('WLSDPLY-09015',
_program_name,
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
def compare(self):
"""
Do the actual compare of the models.
:return: whether the difference is safe for online dynamic update
"""
_method_name = "compare"
# arguments have been verified and same extensions
model_file_name = None
# validate models first
try:
if FileUtils.isYamlFile(JFile(os.path.splitext(self.current_dict_file)[1].lower())):
model_file_name = self.current_dict_file
FileToPython(model_file_name, True).parse()
model_file_name = self.past_dict_file
FileToPython(model_file_name, True).parse()
self.model_context.set_validation_method('lax')
aliases = Aliases(model_context=self.model_context, wlst_mode=WlstModes.OFFLINE,
exception_type=ExceptionType.COMPARE)
validator = Validator(self.model_context, aliases, wlst_mode=WlstModes.OFFLINE)
variable_map = validator.load_variables(self.model_context.get_variable_file())
model_file_name = self.current_dict_file
model_dictionary = cla_helper.merge_model_files(model_file_name, variable_map)
variables.substitute(model_dictionary, variable_map, self.model_context)
# Run this utility in stand-alone mode instead of tool mode,
# which has stricter checks for the tools.
# An archive is not used with the compare models and if the model
# references a file in an archive, the compareModel will fail if
# running in the stricter tool mode (even with lax).
#
arg_map = dict()
arg_map[CommandLineArgUtil.MODEL_FILE_SWITCH] = model_file_name
model_context_copy = self.model_context.copy(arg_map)
val_copy = Validator(model_context_copy, aliases, wlst_mode=WlstModes.OFFLINE)
# any variables should have been substituted at this point
validate_variables = {}
return_code = val_copy.validate_in_standalone_mode(model_dictionary, validate_variables,
archive_file_name=None)
if return_code == Validator.ReturnCode.STOP:
_logger.severe('WLSDPLY-05705', model_file_name)
return VALIDATION_FAIL
current_dict = model_dictionary
model_file_name = self.past_dict_file
model_dictionary = cla_helper.merge_model_files(model_file_name, variable_map)
variables.substitute(model_dictionary, variable_map, self.model_context)
arg_map[CommandLineArgUtil.MODEL_FILE_SWITCH] = model_file_name
model_context_copy = self.model_context.copy(arg_map)
val_copy = Validator(model_context_copy, aliases, wlst_mode=WlstModes.OFFLINE)
return_code = val_copy.validate_in_standalone_mode(model_dictionary, validate_variables,
archive_file_name=None)
if return_code == Validator.ReturnCode.STOP:
_logger.severe('WLSDPLY-05705', model_file_name)
return VALIDATION_FAIL
past_dict = model_dictionary
except ValidateException, te:
_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)
_logger.throwing(ex, class_name=_class_name, method_name=_method_name)
return VALIDATION_FAIL
def compare(self):
"""
Do the actual compare of the models.
:return: whether the difference is safe for online dynamic update
"""
_method_name = "compare"
# arguments have been verified and same extensions
model_file_name = None
# validate models first
try:
if os.path.splitext(self.current_dict_file)[1].lower() == ".yaml":
model_file_name = self.current_dict_file
FileToPython(model_file_name, True).parse()
model_file_name = self.past_dict_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)
variable_map = validator.load_variables(
self.model_context.get_variable_file())
model_file_name = self.current_dict_file
model_dictionary = cla_helper.merge_model_files(
model_file_name, variable_map)
variables.substitute(model_dictionary, variable_map,
self.model_context)
return_code = validator.validate_in_tool_mode(
model_dictionary,
variables_file_name=None,
archive_file_name=None)
if return_code == Validator.ReturnCode.STOP:
__logger.severe('WLSDPLY-05705', model_file_name)
return VALIDATION_FAIL
current_dict = model_dictionary
model_file_name = self.past_dict_file
model_dictionary = cla_helper.merge_model_files(
model_file_name, variable_map)
variables.substitute(model_dictionary, variable_map,
self.model_context)
return_code = validator.validate_in_tool_mode(
model_dictionary,
variables_file_name=None,
archive_file_name=None)
if return_code == Validator.ReturnCode.STOP:
__logger.severe('WLSDPLY-05705', model_file_name)
return VALIDATION_FAIL
past_dict = model_dictionary
except ValidateException, te:
__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)
__logger.throwing(ex,
class_name=_class_name,
method_name=_method_name)
return VALIDATION_FAIL
exit_code = ex.getExitCode()
if exit_code != CommandLineArgUtil.HELP_EXIT_CODE:
__logger.severe('WLSDPLY-20008',
_program_name,
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
method_name=_method_name)
cla_helper.clean_up_temp_files()
# create a minimal model for summary logging
model_context = model_context_helper.create_exit_context(_program_name)
tool_exit.end(model_context, exit_code)
aliases = Aliases(model_context,
wlst_mode=__wlst_mode,
exception_type=ExceptionType.DEPLOY)
model_dictionary = cla_helper.load_model(_program_name, model_context,
aliases, "update", __wlst_mode)
try:
model = Model(model_dictionary)
exit_code = __update(model, model_context, aliases)
except DeployException, ex:
__logger.severe('WLSDPLY-09015',
_program_name,
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
method_name=_method_name)
class Discoverer(object):
"""
Discoverer contains the private methods used to facilitate discovery of the domain information by its subclasses.
"""
def __init__(self, model_context, base_location, wlst_mode, aliases=None):
"""
:param model_context: context about the model for this instance of discover domain
:param base_location: to look for common weblogic resources. By default this is the global path or '/'
"""
self._model_context = model_context
self._base_location = base_location
self._wlst_mode = wlst_mode
if aliases:
self._aliases = aliases
else:
self._aliases = Aliases(self._model_context,
wlst_mode=self._wlst_mode)
self._alias_helper = AliasHelper(self._aliases, _logger,
ExceptionType.DISCOVER)
self._att_handler_map = OrderedDict()
self._wls_version = WebLogicHelper(
_logger).get_actual_weblogic_version()
self._wlst_helper = WlstHelper(_logger, ExceptionType.DISCOVER)
# methods for use only by the subclasses
def _populate_model_parameters(self, dictionary, location):
"""
Populate the model dictionary with the attribute values discovered at the current location. Perform
any special processing for a specific attribute before storing into the model dictionary.
:param dictionary: where to store the discovered attributes
:param location: context containing current location information
:return: dictionary of model attribute name and wlst value
"""
_method_name = '_populate_model_parameters'
wlst_path = self._alias_helper.get_wlst_attributes_path(location)
_logger.finer('WLSDPLY-06100',
wlst_path,
class_name=_class_name,
method_name=_method_name)
if not self.wlst_cd(wlst_path, location):
return
wlst_params = self._get_attributes_for_current_location(location)
_logger.finest('WLSDPLY-06102',
self._wlst_helper.get_pwd(),
wlst_params,
class_name=_class_name,
method_name=_method_name)
wlst_get_params = self._get_required_attributes(location)
_logger.finest('WLSDPLY-06103',
str(location),
wlst_get_params,
class_name=_class_name,
method_name=_method_name)
attr_dict = OrderedDict()
if wlst_params:
for wlst_param in wlst_params:
if wlst_param in wlst_get_params:
_logger.finest('WLSDPLY-06104',
wlst_param,
class_name=_class_name,
method_name=_method_name)
try:
wlst_value = wlst_helper.get(wlst_param)
except PyWLSTException, pe:
_logger.warning('WLSDPLY-06127',
wlst_param,
wlst_path,
pe.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
continue
else:
_logger.finer('WLSDPLY-06131',
wlst_param,
class_name=_class_name,
method_name=_method_name)
wlst_value = wlst_params[wlst_param]
# if type(wlst_value) == str and len(wlst_value) == 0:
# wlst_value = None
_logger.finer('WLSDPLY-06105',
wlst_param,
wlst_value,
wlst_path,
class_name=_class_name,
method_name=_method_name)
try:
model_param, model_value = self._aliases.get_model_attribute_name_and_value(
location, wlst_param, wlst_value)
except AliasException, de:
_logger.info('WLSDPLY-06106',
wlst_param,
wlst_path,
de.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
continue
attr_dict[model_param] = wlst_value
model_value = self._check_attribute(model_param, model_value,
location)
if model_value is not None:
_logger.finer('WLSDPLY-06107',
model_param,
model_value,
class_name=_class_name,
method_name=_method_name)
dictionary[model_param] = model_value
elif model_param is None:
_logger.finest('WLSDPLY-06108',
model_param,
class_name=_class_name,
method_name=_method_name)
class AliasPasswordTestCase(unittest.TestCase):
_logger = PlatformLogger('wlsdeploy.aliases')
_wls_version = '12.2.1.3'
_wlst_password_name = "Password"
_wlst_password_encrypted_name = "PasswordEncrypted"
_passphrase = 'RE a drop of golden sun'
_password = '******'
_encrypted_password = '******'
_encrypted_password_bytes = jarray.array(_encrypted_password, 'b')
def setUp(self):
model_context = ModelContext(
"test", {
CommandLineArgUtil.USE_ENCRYPTION_SWITCH: 'true',
CommandLineArgUtil.PASSPHRASE_SWITCH: self._passphrase
})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = LocationContext()
self.location.append_location(JDBC_SYSTEM_RESOURCE)
self.location.add_name_token(
self.aliases.get_name_token(self.location), "Mine")
self.location.append_location(JDBC_RESOURCE)
self.location.append_location(JDBC_DRIVER_PARAMS)
def testOfflineModelNames(self):
# Using offline WLST, only PasswordEncrypted is an attribute, and its value is encrypted.
# The model name should be PasswordEncrypted.
model_name, model_value = \
self.aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEquals(model_name, PASSWORD_ENCRYPTED)
def testOnlineModelNames(self):
# Using online WLST, both Password and PasswordEncrypted are WLST attributes.
# The PasswordEncrypted WLST attribute should translate to the PasswordEncrypted model attribute.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEqual(model_name, PASSWORD_ENCRYPTED)
# The Password WLST attribute should be skipped, since its value cannot be retrieved.
# This is accomplished by returning a model name of None.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_name,
self._encrypted_password)
self.assertEquals(model_name, None)
def testOfflineWlstNames(self):
# Using offline WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute, regardless of whether the password is encrypted.
# using encrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._password)
# using unencrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_encrypted_name)
def testOnlineWlstNames(self):
# Using online WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute if the password is encrypted, otherwise to Password.
# using encrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED,
self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._password)
# using unencrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_name)
class VariableInjector(object):
def __init__(self, program_name, model, model_context=None, version=None):
"""
Construct an instance of the injector with the model and information used by the injector.
:param program_name: name of the calling tool
:param model: to be updated with variables
:param model_context: context with command line information
:param version: of model if model context is not provided
"""
self.__program_name = program_name
self.__original = copy.deepcopy(model)
self.__model = model
self.__model_context = model_context
if self.__model_context:
self.__wlst_mode = self.__model_context.get_target_wlst_mode()
else:
self.__wlst_mode = WlstModes.OFFLINE
self.__section_keys = model_sections.get_model_top_level_keys()
self.__section_keys.remove(model_sections.get_model_domain_info_key())
if version:
self.__aliases = Aliases(model_context, self.__wlst_mode, version,
None)
else:
self.__aliases = Aliases(model_context)
def inject_variables_keyword_file(self, **kwargs):
"""
Replace attribute values with variables and generate a variable dictionary.
The variable replacement is driven from the values in the model variable helper file.
This file can either contain the name of a replacement file, or a list of pre-defined
keywords for canned replacement files.
Return the variable dictionary with the variable name inserted into the model, and the value
that the inserted variable replaced.
:param kwargs: arguments used to override default for variable processing, typically used in test situations
:return: variable dictionary containing
"""
_method_name = 'inject_variables_keyword_file'
_logger.entering(class_name=_class_name, method_name=_method_name)
variable_injector_location_file = _get_variable_injector_file_name(
**kwargs)
variables_injector_dictionary = _load_variable_injector_file(
variable_injector_location_file)
variable_keywords_location_file = _get_variable_keywords_file_name(
**kwargs)
keywords_dictionary = _load_keywords_file(
variable_keywords_location_file)
variables_inserted = False
return_model = self.__original
variable_file_location = None
if variables_injector_dictionary and keywords_dictionary:
variable_file_location = self._get_variable_file_name(**kwargs)
if not variable_file_location:
_logger.warning('WLSDPLY-19520',
variable_injector_location_file,
class_name=_class_name,
method_name=_method_name)
else:
_logger.info('WLSDPLY-19533',
variable_injector_location_file,
class_name=_class_name,
method_name=_method_name)
append, stage_dictionary = _load_variable_file(
variable_file_location, **kwargs)
injector_file_list = _create_injector_file_list(
variables_injector_dictionary, keywords_dictionary,
_get_keyword_files_location(**kwargs))
variables_file_dictionary = self.inject_variables_keyword_dictionary(
injector_file_list)
if variables_file_dictionary:
stage_dictionary.update(variables_file_dictionary)
variables_inserted = self._write_variables_file(
stage_dictionary, variable_file_location, append)
if variables_inserted:
_logger.info('WLSDPLY-19518',
variable_file_location,
class_name=_class_name,
method_name=_method_name)
return_model = self.__model
else:
_logger.info('WLSDPLY-19519',
class_name=_class_name,
method_name=_method_name)
variable_file_location = None
else:
_logger.info('WLSDPLY-19532',
variable_injector_location_file,
class_name=_class_name,
method_name=_method_name)
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=variables_inserted)
return variables_inserted, return_model, variable_file_location
def inject_variables_keyword_dictionary(self, injector_file_list):
"""
Takes a variable keyword dictionary and returns a variables for file in a dictionary
:param injector_file_list: list of injector files for processing variable injection
:return: variables_dictionary containing the variable properties to persist to the variable file
"""
_method_name = 'inject_variables_keyword_dictionary'
_logger.entering(injector_file_list,
class_name=_class_name,
method_name=_method_name)
variable_dictionary = dict()
for filename in injector_file_list:
injector_dictionary = _load_injector_file(
self._replace_tokens(filename))
entries = self.inject_variables(injector_dictionary)
if entries:
_logger.finer('WLSDPLY-19513',
filename,
class_name=_class_name,
method_name=_method_name)
variable_dictionary.update(entries)
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=variable_dictionary)
return variable_dictionary
def inject_variables(self, injector_dictionary):
"""
Iterate through the injector dictionary that was loaded from the file for the model
injector file keyword.
:param injector_dictionary:
:return: variable dictionary containing the variable string and model value entries
"""
variable_dict = dict()
if injector_dictionary:
location = LocationContext()
domain_token = self.__aliases.get_name_token(location)
location.add_name_token(domain_token, _fake_name_marker)
for injector, injector_values in injector_dictionary.iteritems():
entries_dict = self.__inject_variable(location, injector,
injector_values)
if len(entries_dict) > 0:
variable_dict.update(entries_dict)
return variable_dict
def __inject_variable(self, location, injector, injector_values):
_method_name = '__inject_variable'
_logger.entering(injector,
class_name=_class_name,
method_name=_method_name)
variable_dict = dict()
start_mbean_list, attribute = _split_injector(injector)
def _traverse_variables(model_section, mbean_list):
if mbean_list:
mbean = mbean_list.pop(0)
mbean, mbean_name_list = self._find_special_name(mbean)
_logger.finer('WLSDPLY-19523',
mbean,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
if mbean in model_section:
_logger.finest('WLSDPLY-19514',
mbean,
class_name=_class_name,
method_name=_method_name)
next_model_section = model_section[mbean]
location.append_location(mbean)
name_token = self.__aliases.get_name_token(location)
if not mbean_name_list:
if self.__aliases.supports_multiple_mbean_instances(
location):
mbean_name_list = next_model_section
else:
self._check_name_token(location, name_token)
else:
_logger.fine('WLSDPLY-19506',
mbean_name_list,
attribute,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
if mbean_name_list:
for mbean_name in mbean_name_list:
if mbean_name in next_model_section:
continue_mbean_list = copy.copy(mbean_list)
location.add_name_token(name_token, mbean_name)
_traverse_variables(
next_model_section[mbean_name],
continue_mbean_list)
location.remove_name_token(name_token)
else:
_traverse_variables(next_model_section, mbean_list)
location.pop_location()
else:
self._log_mbean_not_found(mbean, injector, location)
return False
else:
self._check_insert_attribute_model(location, model_section,
attribute, injector_values)
if attribute in model_section:
returned_dict = self._variable_info(
model_section, attribute, location, injector_values)
if returned_dict:
variable_dict.update(returned_dict)
else:
_logger.finer('WLSDPLY-19517',
attribute,
injector,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
return True
section = self.__model
if start_mbean_list:
# Find out in what section is the mbean top folder so can move to that section in the model
top_mbean, __ = self._find_special_name(start_mbean_list[0])
for entry in self.__section_keys:
if entry in self.__model and top_mbean in self.__model[entry]:
section = self.__model[entry]
break
else:
# This is a domain attribute
section = self.__model[model_sections.get_model_topology_key()]
# if it wasn't found, will log appropriately in the called method
# This also will allow someone to put the section in the injector string
_traverse_variables(section, start_mbean_list)
_logger.exiting(class_name=_class_name,
method_name=_method_name,
result=variable_dict)
return variable_dict
def __format_variable_name(self, location, attribute):
_method_name = '__format_variable_name'
variable_name = attribute
make_path = None
try:
make_path = self.__aliases.get_model_folder_path(location)
except AliasException, ae:
_logger.warning('WLSDPLY-19531',
str(location),
attribute,
ae.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
if make_path:
make_path = make_path.split(':')
if len(make_path) > 1 and len(make_path[1]) > 1:
variable_name = make_path[1]
variable_name = variable_name[1:] + VARIABLE_SEP + attribute
return _massage_name(variable_name)
variable_file = model_context.get_variable_file()
variables = None
if variable_file is not None:
try:
variables = variable_helper.load_variables(variable_file)
except VariableException, ve:
__logger.severe('WLSDPLY-04207',
_program_name,
variable_file,
ve.getLocalizedMessage(),
error=ve,
class_name=_class_name,
method_name=_method_name)
return CommandLineArgUtil.PROG_ERROR_EXIT_CODE
aliases = Aliases(model_context, wlst_mode=WlstModes.OFFLINE)
alias_helper = AliasHelper(aliases, __logger, ExceptionType.ENCRYPTION)
try:
passphrase = model_context.get_encryption_passphrase()
model_change_count, variable_change_count = \
encryption_utils.encrypt_model_dictionary(passphrase, model, alias_helper, variables)
except EncryptionException, ee:
__logger.severe('WLSDPLY-04208',
_program_name,
ee.getLocalizedMessage(),
error=ee,
class_name=_class_name,
method_name=_method_name)
return CommandLineArgUtil.PROG_ERROR_EXIT_CODE
class AliasPasswordTestCase(unittest.TestCase):
_logger = PlatformLogger('wlsdeploy.aliases')
_wls_version = '12.2.1.3'
_wlst_password_name = "Password"
_wlst_password_encrypted_name = "PasswordEncrypted"
_password = '******'
_encrypted_password = '******'
_encrypted_password_bytes = jarray.array(_encrypted_password, 'b')
def setUp(self):
model_context = ModelContext("test", {})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = LocationContext()
self.location.append_location(JDBC_SYSTEM_RESOURCE)
self.location.add_name_token(
self.aliases.get_name_token(self.location), "Mine")
self.location.append_location(JDBC_RESOURCE)
self.location.append_location(JDBC_DRIVER_PARAMS)
def testOfflineModelNames(self):
# Using offline WLST, only PasswordEncrypted is an attribute, and its value is encrypted.
# The model name should be PasswordEncrypted.
model_name, model_value = \
self.aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEquals(model_name, PASSWORD_ENCRYPTED)
def testOnlineModelNames(self):
# Using online WLST, both Password and PasswordEncrypted are WLST attributes.
# The PasswordEncrypted WLST attribute should translate to the PasswordEncrypted model attribute.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEqual(model_name, PASSWORD_ENCRYPTED)
# The Password WLST attribute should be skipped, since its value cannot be retrieved.
# This is accomplished by returning a model name of None.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_name,
self._encrypted_password)
self.assertEquals(model_name, None)
def testOfflineWlstNames(self):
# Using offline WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute, regardless of whether the password is encrypted.
# using encrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
# using unencrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_encrypted_name)
def testOnlineWlstNames(self):
# Using online WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute if the password is encrypted, otherwise to Password.
# using encrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED,
self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
# using unencrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_name)
class Discoverer(object):
"""
Discoverer contains the private methods used to facilitate discovery of the domain information by its subclasses.
"""
def __init__(self,
model_context,
base_location,
wlst_mode,
aliases=None,
credential_injector=None):
"""
:param model_context: context about the model for this instance of discover domain
:param base_location: to look for common weblogic resources. By default this is the global path or '/'
:param wlst_mode: offline or online
:param aliases: optional, aliases object to use
:param credential_injector: optional, injector to collect credentials
"""
self._model_context = model_context
self._base_location = base_location
self._wlst_mode = wlst_mode
if aliases:
self._aliases = aliases
else:
self._aliases = Aliases(self._model_context,
wlst_mode=self._wlst_mode,
exception_type=ExceptionType.DISCOVER)
self._credential_injector = credential_injector
self._att_handler_map = OrderedDict()
self._custom_folder = CustomFolderHelper(self._aliases, _logger,
self._model_context,
ExceptionType.DISCOVER,
self._credential_injector)
self._weblogic_helper = WebLogicHelper(_logger)
self._wlst_helper = WlstHelper(ExceptionType.DISCOVER)
self._mbean_utils = MBeanUtils(self._model_context, self._aliases,
ExceptionType.DISCOVER)
self._wls_version = self._weblogic_helper.get_actual_weblogic_version()
def discover_domain_mbean(self, model_top_folder_name):
"""
Discover the domain specific MBean and its configuration attributes.
:return: model name for domain MBean:dictionary containing the discovered Domain MBean attributes
"""
_method_name = 'discover_domain_mbean'
_logger.entering(model_top_folder_name,
class_name=_class_name,
method_name=_method_name)
result = OrderedDict()
location = LocationContext(self._base_location)
location.append_location(model_top_folder_name)
name = self._find_singleton_name_in_folder(location)
if name is not None:
_logger.info('WLSDPLY-06644',
model_top_folder_name,
class_name=_class_name,
method_name=_method_name)
location.add_name_token(self._aliases.get_name_token(location),
name)
self._populate_model_parameters(result, location)
# if any subfolders exist, discover
self._discover_subfolders(result, location)
_logger.exiting(class_name=_class_name, method_name=_method_name)
return model_top_folder_name, result
# methods for use only by the subclasses
def _populate_model_parameters(self, dictionary, location):
"""
Populate the model dictionary with the attribute values discovered at the current location. Perform
any special processing for a specific attribute before storing into the model dictionary.
:param dictionary: where to store the discovered attributes
:param location: context containing current location information
:return: dictionary of model attribute name and wlst value
"""
_method_name = '_populate_model_parameters'
wlst_path = self._aliases.get_wlst_attributes_path(location)
_logger.finer('WLSDPLY-06100',
wlst_path,
class_name=_class_name,
method_name=_method_name)
if not self.wlst_cd(wlst_path, location):
return
wlst_lsa_params = self._get_attributes_for_current_location(location)
_logger.finest('WLSDPLY-06102',
self._wlst_helper.get_pwd(),
wlst_lsa_params,
class_name=_class_name,
method_name=_method_name)
wlst_get_params = self._get_required_attributes(location)
_logger.finest('WLSDPLY-06103',
str(location),
wlst_get_params,
class_name=_class_name,
method_name=_method_name)
if wlst_lsa_params is not None:
for wlst_lsa_param in wlst_lsa_params:
if wlst_lsa_param in wlst_get_params:
success, wlst_value = self._get_attribute_value_with_get(
wlst_lsa_param, wlst_path)
if not success:
continue
else:
_logger.finer('WLSDPLY-06131',
wlst_lsa_param,
class_name=_class_name,
method_name=_method_name)
wlst_value = wlst_lsa_params[wlst_lsa_param]
self._add_to_dictionary(dictionary, location, wlst_lsa_param,
wlst_value, wlst_path)
# These will come after the lsa / get params in the ordered dictionary
wlst_extra_params = self._get_additional_parameters(location)
_logger.finest('WLSDPLY-06149',
str(location),
wlst_extra_params,
class_name=_class_name,
method_name=_method_name)
if wlst_extra_params is not None:
for wlst_extra_param in wlst_extra_params:
if wlst_extra_param in wlst_get_params:
success, wlst_value = self._get_attribute_value_with_get(
wlst_extra_param, wlst_path)
if success:
self._add_to_dictionary(dictionary, location,
wlst_extra_param, wlst_value,
wlst_path)
else:
_logger.info('WLSDPLY-06152',
wlst_extra_param,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
elif self._is_defined_attribute(location, wlst_extra_param):
_logger.info('WLSDPLY-06154',
wlst_extra_param,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
else:
_logger.info('WLSDPLY-06153',
wlst_extra_param,
location.get_folder_path(),
class_name=_class_name,
method_name=_method_name)
def _get_attribute_value_with_get(self, wlst_get_param, wlst_path):
_method_name = '_get_attribute_value_with_get'
_logger.finest('WLSDPLY-06104',
wlst_get_param,
class_name=_class_name,
method_name=_method_name)
success = False
wlst_value = None
try:
wlst_value = self._wlst_helper.get(wlst_get_param)
success = True
except DiscoverException, pe:
_logger.warning('WLSDPLY-06127',
wlst_get_param,
wlst_path,
pe.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
return success, wlst_value
class AliasPasswordTestCase(unittest.TestCase):
"""
Test domain-encrypted passwords in a model.
"""
_logger = PlatformLogger('wlsdeploy.aliases')
_wls_version = '12.2.1.3'
_wlst_password_name = "Password"
_wlst_password_encrypted_name = "PasswordEncrypted"
_password = '******'
_encrypted_password = '******'
def setUp(self):
model_context = ModelContext("test", {})
self.aliases = Aliases(model_context,
wlst_mode=WlstModes.OFFLINE,
wls_version=self._wls_version)
self.online_aliases = Aliases(model_context,
wlst_mode=WlstModes.ONLINE,
wls_version=self._wls_version)
self.location = aliases_test.get_jdbc_driver_params_location(
"Mine", self.aliases)
def testOfflineModelNames(self):
# Using offline WLST, only PasswordEncrypted is an attribute, and its value is encrypted.
# The model name should be PasswordEncrypted.
model_name, model_value = \
self.aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEquals(model_name, PASSWORD_ENCRYPTED)
def testOnlineModelNames(self):
# Using online WLST, both Password and PasswordEncrypted are WLST attributes.
# The PasswordEncrypted WLST attribute should translate to the PasswordEncrypted model attribute.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_encrypted_name,
self._encrypted_password)
self.assertEqual(model_name, PASSWORD_ENCRYPTED)
# The Password WLST attribute should be skipped, since its value cannot be retrieved.
# This is accomplished by returning a model name of None.
model_name, model_value = \
self.online_aliases.get_model_attribute_name_and_value(self.location, self._wlst_password_name,
self._encrypted_password)
self.assertEquals(model_name, None)
def testOfflineWlstNames(self):
# Using offline WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute, regardless of whether the password is encrypted.
# using encrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._encrypted_password)
# using unencrypted password
wlst_name, wlst_value = \
self.aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_encrypted_name)
def testOnlineWlstNames(self):
# Using online WLST, the PasswordEncrypted model attribute should translate to the PasswordEncrypted WLST
# attribute if the password is encrypted, otherwise to Password.
# using encrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED,
self._encrypted_password)
self.assertEqual(wlst_name, self._wlst_password_encrypted_name)
self.assertEqual(wlst_value, self._encrypted_password)
# using unencrypted password
wlst_name, wlst_value = \
self.online_aliases.get_wlst_attribute_name_and_value(self.location, PASSWORD_ENCRYPTED, self._password)
self.assertEquals(wlst_name, self._wlst_password_name)
