def testDeleteModelAppDeployments(self):
_method_name = 'testCompareModelFull'
_variables_file = self._resources_dir + '/compare_model_model1.10.properties'
_new_model_file = self._resources_dir + '/compare_model_model5.yaml'
_old_model_file = self._resources_dir + '/compare_model_model1.yaml'
_temp_dir = os.path.join(tempfile.gettempdir(), _method_name)
if os.path.exists(_temp_dir):
shutil.rmtree(_temp_dir)
os.mkdir(_temp_dir)
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-variable_file': _variables_file,
'-output_dir': _temp_dir,
'-domain_type': 'WLS',
'-trailing_arguments': [_new_model_file, _old_model_file]
}
try:
model_context = ModelContext('CompareModelTestCase', args_map)
obj = ModelFileDiffer(_new_model_file, _old_model_file,
model_context, _temp_dir)
return_code = obj.compare()
self.assertEqual(return_code, 0)
yaml_result = _temp_dir + os.sep + 'diffed_model.yaml'
stdout_result = obj.get_compare_msgs()
model_dictionary = FileToPython(yaml_result).parse()
yaml_exists = os.path.exists(yaml_result)
self.assertEqual(yaml_exists, True)
self.assertEqual(len(stdout_result), 0)
self.assertEqual(model_dictionary.has_key('appDeployments'), True)
self.assertEqual(
model_dictionary['appDeployments'].has_key('Library'), True)
self.assertEqual(
model_dictionary['appDeployments'].has_key('Application'),
True)
self.assertEqual(
model_dictionary['appDeployments']['Application'].has_key(
'!myear'), True)
self.assertEqual(
model_dictionary['appDeployments']['Library'].has_key(
'!jax-rs#[email protected]'), True)
self.assertEqual(
model_dictionary['appDeployments']['Library'].has_key(
'!jsf#[email protected]'), True)
except (CompareException, PyWLSTException), te:
return_code = 2
self._logger.severe('WLSDPLY-05709',
te.getLocalizedMessage(),
error=te,
class_name=self._program_name,
method_name=_method_name)
def testMultipleModelsIndirectEncryptionVariables(self):
copy2(self._src_model_file_w_variables, self._target_model_test2)
copy2(self._src_model_file_w_variables_multi, self._target_model_test3)
copy2(self._src_variable_file, self._target_variables_test3)
args = list()
args.append(
'encrypt') # dummy arg for args[0] to get arg padding right
args.append(CommandLineArgUtil.ORACLE_HOME_SWITCH)
args.append(self._oracle_home)
args.append(CommandLineArgUtil.MODEL_FILE_SWITCH)
args.append(self._target_model_test2 + ',' + self._target_model_test3)
args.append(CommandLineArgUtil.VARIABLE_FILE_SWITCH)
args.append(self._target_variables_test3)
args.append(CommandLineArgUtil.PASSPHRASE_SWITCH)
args.append(self._passphrase)
exit_code = encrypt._process_request(args)
self.assertEquals(exit_code, 0)
model2 = FileToPython(self._target_model_test2).parse()
model3 = FileToPython(self._target_model_test3).parse()
variables = variables_helper.load_variables(
self._target_variables_test3)
passphrase_array = String(self._passphrase).toCharArray()
admin_pass = model2['domainInfo']['AdminPassword']
self.assertNotEquals(admin_pass.startswith('{AES}'), True)
admin_pass = model3['domainInfo']['AdminPassword']
self.assertNotEquals(admin_pass.startswith('{AES}'), True)
admin_pass = variables['admin.password']
self.assertEquals(admin_pass.startswith('{AES}'), True)
_decrypted_admin_pass = EncryptionUtils.decryptString(
admin_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_admin_pass)),
self._unencrypted_password)
nm_pass = model2['topology']['SecurityConfiguration'][
'NodeManagerPasswordEncrypted']
self.assertNotEquals(nm_pass.startswith('{AES}'), True)
nm_pass = variables['nm.password']
self.assertEquals(nm_pass.startswith('{AES}'), True)
_decrypted_nm_pass = EncryptionUtils.decryptString(
nm_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_nm_pass)),
self._unencrypted_password)
ds1_pass = model2['resources']['JDBCSystemResource']['Generic1'][
'JdbcResource']['JDBCDriverParams']['PasswordEncrypted']
self.assertEquals(ds1_pass.startswith('{AES}'), True)
_decrypted_ds1_pass = EncryptionUtils.decryptString(
ds1_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_ds1_pass)),
self._unencrypted_password)
return
def testJsonToPython(self):
translator = FileToPython(self._src_json_file, use_ordering=True)
pythonDict = translator.parse()
self.assertNotEqual(pythonDict, None)
self.assertEqual(len(pythonDict), 2)
quotedValue = pythonDict['foo']
self.assertEqual(quotedValue, 'this is a "legal" JSON value')
self.assertEqual('keys "can" have quotes too' in pythonDict, True)
quotedKeyValue = pythonDict['keys "can" have quotes too']
self.assertEqual(quotedKeyValue, 123)
def testYamlToPython(self):
translator = FileToPython(self._src_yaml_file, use_ordering=True)
pythonDict = translator.parse()
self.assertNotEqual(pythonDict, None)
self.assertEqual(len(pythonDict), 3)
quotedValue = pythonDict['foo']
self.assertEqual(quotedValue, 'test \'legal\' yaml')
quotedValue = pythonDict['bar']
self.assertEqual(quotedValue, 'test "legal" yaml')
quotedValue = pythonDict['baz']
self.assertEqual(quotedValue, 'test \'legal\' yaml')
def apply_filters(model, tool_type):
"""
Apply any filters configured for the specified tool type to the specified model.
:param model: the model to be filtered
:param tool_type: the name of the filter tool type
:return: True if any filter was applied, False otherwise
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = 'apply_filters'
filter_applied = False
try:
if os.path.isfile(__filter_file_location):
filters_dictionary = FileToPython(__filter_file_location).parse()
if tool_type in filters_dictionary:
filter_list = filters_dictionary[tool_type]
for filter in filter_list:
filter_applied = _apply_filter(model, filter) or filter_applied
else:
__logger.info('WLSDPLY-20016', tool_type, __filter_file_location, class_name=__class_name,
method_name=_method_name)
else:
__logger.info('WLSDPLY-20017', __filter_file_location, class_name=__class_name, method_name=_method_name)
except Exception, ex:
__logger.severe('WLSDPLY-20018', str(ex), error=ex, class_name=__class_name, method_name=_method_name)
def translate_file(from_file, logger):
"""
Returns a Python dictionary representation of the from_file argument.
If from_file is a string, the assumption taken is that it's the name
of a JSON file. In that case, the verify_file_exists(file_name) method
will be called on it, first. That method returns a Jython File object,
which is what this translate_file(from_file) method works with.
:param from_file: A File
:param logger: A PlatformLogger instance that will be used for logging
any exceptions that are thrown
:return: A Python dictionary representation of the from_file argument
:raises: TestingException: if a TranslateException is caught during the translation
"""
_method_name = 'translate_file'
try:
if isinstance(from_file, str):
from_file = verify_file_exists(from_file, logger)
from_file_dict = FileToPython(from_file.getAbsolutePath(),
True).parse()
except TranslateException, te:
ex = exception_helper.create_testing_exception(
'WLSDPLY-09807',
from_file.getAbsolutePath(),
te.getLocalizedMessage(),
error=te)
logger.throwing(ex, class_name=_class_name, method_name=_method_name)
raise ex
def __compare_models(compare_models_args_map):
"""
:param compare_models_args_map:
:return:
:raises CompareModelsException:
:raises VerificationException:
"""
_method_name = '__compare_models'
expected_model_file = None
try:
expected_model_file = compare_models_args_map[
_EXPECTED_MODEL_FILE_SWITCH]
expected_model_dict = FileToPython(
expected_model_file.getAbsolutePath(), True).parse()
except TranslateException, te:
__logger.severe('WLSDPLY-20009',
_program_name,
expected_model_file.getAbsolutePath(),
te.getLocalizedMessage(),
error=te,
class_name=_class_name,
method_name=_method_name)
ex = exception_helper.create_verification_exception(
te.getLocalizedMessage(), error=te)
__logger.throwing(ex, class_name=_class_name, method_name=_method_name)
raise ex
def testPythonToYaml(self):
pythonDict = dict()
pythonDict['foo'] = 'test \'legal\' yaml'
pythonDict['bar'] = 'test "legal" yaml'
pythonDict['baz'] = 'test \'legal\' yaml'
pythonDict['newline'] = 'test embedded\nnewline yaml'
translator = PythonToFile(pythonDict)
translator.write_to_file(self._target_yaml_file)
translator = FileToPython(self._target_yaml_file, use_ordering=True)
newPythonDict = translator.parse()
self.assertEqual('foo' in newPythonDict, True)
self.assertEqual('bar' in newPythonDict, True)
self.assertEqual('baz' in newPythonDict, True)
self.assertEquals('newline' in newPythonDict, True)
quotedValue = newPythonDict['foo']
self.assertEqual(quotedValue, 'test \'legal\' yaml')
quotedValue = newPythonDict['bar']
self.assertEqual(quotedValue, 'test "legal" yaml')
quotedValue = newPythonDict['baz']
self.assertEqual(quotedValue, 'test \'legal\' yaml')
quotedValue = newPythonDict['newline']
self.assertEqual(quotedValue, 'test embedded\nnewline yaml')
def testFilterInvokedOnModelValidation(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 = 'testFilterInvokedOnModelValidation'
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)
try:
# Invoke model validation
__perform_model_file_validation(_model_file, model_context)
# read persisted model file and convert to python dictionary
model_dictionary = FileToPython(self._wlsdeply_store_model,
True)._parse_json()
except ValidateException, ve:
self._logger.severe('WLSDPLY-20000',
self._program_name,
ve.getLocalizedMessage(),
error=ve,
class_name=self._class_name,
method_name=_method_name)
def testModelValidation(self):
_method_name = 'testModelValidation'
_model_file = self._resources_dir + '/variablestest.yaml'
_variable_file = self._resources_dir + '/variablestest.properties'
_archive_file = self._resources_dir + '/variablestest.zip'
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-model_file': _model_file,
'-variable_file': _variable_file,
'-archive_file': _archive_file
}
model_context = ModelContext('ValidationTestCase', args_map)
try:
model_dictionary = FileToPython(model_context.get_model_file()).parse()
model_validator = Validator(model_context,
wlst_mode=WlstModes.ONLINE)
return_code = model_validator.validate_in_tool_mode(model_dictionary,
model_context.get_variable_file(),
model_context.get_archive_file_name())
self._logger.info('The Validator.validate_in_tool_mode() call returned {0}',
Validator.ReturnCode.from_value(return_code),
class_name=self._class_name, method_name=_method_name)
except TranslateException, te:
return_code = Validator.ReturnCode.STOP
self._logger.severe('WLSDPLY-20009',
self._program_name,
model_context.get_model_file(),
te.getLocalizedMessage(), error=te,
class_name=self._class_name, method_name=_method_name)
def testYamlModelValidation(self):
"""
Parse and validate a YAML model with '-' list type and attributes with negative values.
"""
_model_file = self._resources_dir + '/simple-model.yaml'
_archive_file = self._resources_dir + "/SingleAppDomain.zip"
_method_name = 'testYamlModelValidation'
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-model_file': _model_file,
'-archive_file': _archive_file
}
model_context = ModelContext('ValidationTestCase', args_map)
try:
model_dictionary = FileToPython(model_context.get_model_file()).parse()
model_validator = Validator(model_context,
wlst_mode=WlstModes.ONLINE)
return_code = model_validator.validate_in_tool_mode(model_dictionary,
model_context.get_variable_file(),
model_context.get_archive_file_name())
self._logger.info('The Validator.validate_in_tool_mode() call returned {0}',
Validator.ReturnCode.from_value(return_code),
class_name=self._class_name, method_name=_method_name)
except TranslateException, te:
return_code = Validator.ReturnCode.STOP
self._logger.severe('WLSDPLY-20009',
self._program_name,
model_context.get_model_file(),
te.getLocalizedMessage(), error=te,
class_name=self._class_name, method_name=_method_name)
def testDirectEncryption(self):
copy2(self._src_model_file_wo_variables, self._target_model_test1)
args = list()
args.append(
'encrypt') # dummy arg for args[0] to get arg padding right
args.append(CommandLineArgUtil.ORACLE_HOME_SWITCH)
args.append(self._oracle_home)
args.append(CommandLineArgUtil.MODEL_FILE_SWITCH)
args.append(self._target_model_test1)
args.append(CommandLineArgUtil.PASSPHRASE_SWITCH)
args.append(self._passphrase)
exit_code = encrypt._process_request(args)
self.assertEquals(exit_code, 0)
model = FileToPython(self._target_model_test1).parse()
passphrase_array = String(self._passphrase).toCharArray()
admin_pass = model['domainInfo']['AdminPassword']
self.assertEquals(admin_pass.startswith('{AES}'), True)
_decrypted_admin_pass = EncryptionUtils.decryptString(
admin_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_admin_pass)),
self._unencrypted_password)
nm_pass = model['topology']['SecurityConfiguration'][
'NodeManagerPasswordEncrypted']
self.assertEquals(nm_pass.startswith('{AES}'), True)
_decrypted_nm_pass = EncryptionUtils.decryptString(
nm_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_nm_pass)),
self._unencrypted_password)
ds1_pass = model['resources']['JDBCSystemResource']['Generic1'][
'JdbcResource']['JDBCDriverParams']['PasswordEncrypted']
self.assertEquals(ds1_pass.startswith('{AES}'), True)
_decrypted_ds1_pass = EncryptionUtils.decryptString(
ds1_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_ds1_pass)),
self._unencrypted_password)
ons_pass = \
model['resources']['JDBCSystemResource']['Generic1']['JdbcResource']['JDBCOracleParams']['OnsWalletPasswordEncrypted']
self.assertEquals(ons_pass.startswith('{AES}'), True)
_decrypted_ons_pass = EncryptionUtils.decryptString(
ons_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_ons_pass)),
self._unencrypted_password)
ds2_pass = model['resources']['JDBCSystemResource']['Generic2'][
'JdbcResource']['JDBCDriverParams']['PasswordEncrypted']
self.assertEquals(ds2_pass.startswith('{AES}'), True)
_decrypted_ds2_pass = EncryptionUtils.decryptString(
ds2_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_ds2_pass)),
self._unencrypted_password)
return
def testSubstituteJson(self):
model = FileToPython(self._resources_dir + '/variables-test.json', self._use_ordering).parse()
variable_map = variables.load_variables(self._variables_file)
variables.substitute(model, variable_map, self.model_context)
self.assertEqual(model['topology']['Name'], 'xyz123')
self.assertEqual(model['topology']['Server']['s1']['ListenPort'], '1009')
self.assertEqual(model['topology']['Server']['s2']['Cluster'], 'myCluster')
self.assertEqual(True, 'myCluster' in model['topology']['Cluster'])
self.assertEqual(True, 's3' in model['topology']['Server'])
def testVariableNotFound(self):
"""
For ${key} substitution, no replacement is done, and no error is reported, if variable not found.
${key} substitution is deprecated.
"""
model = FileToPython(self._resources_dir + '/variables-test.json', self._use_ordering).parse()
model['topology']['Name'] = '${bad.variable}'
variable_map = variables.load_variables(self._variables_file)
variables.substitute(model, variable_map)
self.assertEqual(model['topology']['Name'], '${bad.variable}')
def testMultipleModelsDirectAndVariables(self):
copy2(self._src_model_file_w_variables, self._target_model_test1)
copy2(self._src_model_file_wo_variables_for_multi,
self._target_model_test2)
copy2(self._src_variable_file, self._target_variables_test3)
args = list()
args.append(
'encrypt') # dummy arg for args[0] to get arg padding right
args.append(CommandLineArgUtil.ORACLE_HOME_SWITCH)
args.append(self._oracle_home)
args.append(CommandLineArgUtil.MODEL_FILE_SWITCH)
args.append(self._target_model_test1 + ',' + self._target_model_test2)
args.append(CommandLineArgUtil.VARIABLE_FILE_SWITCH)
args.append(self._target_variables_test3)
args.append(CommandLineArgUtil.PASSPHRASE_SWITCH)
args.append(self._passphrase)
exit_code = encrypt._process_request(args)
self.assertEquals(exit_code, 0)
model2 = FileToPython(self._target_model_test1).parse()
model3 = FileToPython(self._target_model_test2).parse()
variables = variables_helper.load_variables(
self._target_variables_test3)
passphrase_array = String(self._passphrase).toCharArray()
admin_pass = model2['domainInfo']['AdminPassword']
self.assertNotEquals(admin_pass.startswith('{AES}'), True)
admin_pass = variables['admin.password']
self.assertEquals(admin_pass.startswith('{AES}'), True)
_decrypted_admin_pass = EncryptionUtils.decryptString(
admin_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_admin_pass)),
self._unencrypted_password)
admin_pass = model3['domainInfo']['AdminPassword']
self.assertEquals(admin_pass.startswith('{AES}'), True)
_decrypted_admin_pass = EncryptionUtils.decryptString(
admin_pass, passphrase_array)
self.assertEquals(str(String(_decrypted_admin_pass)),
self._unencrypted_password_second)
return
def testPropertyNotFound(self):
"""
For @@PROP:key@@ substitution, an exception is thrown if variable not found.
"""
try:
model = FileToPython(self._resources_dir + '/variables-test.json', self._use_ordering).parse()
model['topology']['Name'] = '@@PROP:bad.variable@@'
variable_map = variables.load_variables(self._variables_file)
variables.substitute(model, variable_map, self.model_context)
except VariableException:
pass
else:
self.fail('Test must raise VariableException when variable is not found')
def apply_filters(model, tool_type, model_context=None):
"""
Apply any filters configured for the specified tool type to the specified model.
:param model: the model to be filtered
:param tool_type: the name of the filter tool type
:param model_context: optional, used to find target filters
:return: True if any filter was applied, False otherwise
:raises: BundleAwareException of the specified type: if an error occurs
"""
_method_name = 'apply_filters'
global __filter_file_location
__filter_file_location = path_utils.find_config_path('model_filters.json')
filter_applied = False
target_configuration = None
try:
filters_dictionary = {}
# if target specified in model context, use the filters from target config
if model_context:
target_configuration = model_context.get_target_configuration()
if target_configuration and 'model_filters' in target_configuration:
filters_dictionary = target_configuration['model_filters']
target_path = os.path.join('targets', model_context.get_target())
# Fix the tokenized path in the filter path
for filter_list in filters_dictionary:
for current_filter in filters_dictionary[filter_list]:
filter_path = dictionary_utils.get_element(current_filter, 'path')
if (filter_path is not None) and filter_path.startswith(TARGET_CONFIG_TOKEN):
filter_path = target_path + filter_path.replace(TARGET_CONFIG_TOKEN, '')
current_filter['path'] = path_utils.find_config_path(filter_path)
elif os.path.isfile(__filter_file_location):
filters_dictionary = FileToPython(__filter_file_location).parse()
else:
__logger.info('WLSDPLY-20017', __filter_file_location, class_name=__class_name, method_name=_method_name)
if tool_type in filters_dictionary:
filter_list = filters_dictionary[tool_type]
for filter in filter_list:
filter_applied = _apply_filter(model, filter) or filter_applied
else:
__logger.info('WLSDPLY-20016', tool_type, __filter_file_location, class_name=__class_name,
method_name=_method_name)
except Exception, ex:
__logger.severe('WLSDPLY-20018', str(ex), error=ex, class_name=__class_name, method_name=_method_name)
def testPythonToJson(self):
pythonDict = dict()
pythonDict['foo'] = 'this is a "legal" JSON value'
pythonDict['keys "can" have quotes too'] = 123
translator = PythonToFile(pythonDict)
translator.write_to_file(self._target_json_file)
translator = FileToPython(self._target_json_file)
newPythonDict = translator.parse()
self.assertEqual('foo' in newPythonDict, True)
self.assertEqual('keys "can" have quotes too' in newPythonDict, True)
self.assertEqual(newPythonDict['foo'], 'this is a "legal" JSON value')
self.assertEqual(newPythonDict['keys "can" have quotes too'], 123)
def merge_model_files(model_file_value):
"""
Merge the model files specified by the model file value.
It may be a single file, or a comma-separated list of files.
:param model_file_value: the value specified as a command argument
:return: the merge model dictionary
"""
merged_model = OrderedDict()
model_files = cla_utils.get_model_files(model_file_value)
for model_file in model_files:
model = FileToPython(model_file, True).parse()
_merge_dictionaries(merged_model, model)
return merged_model
def __encrypt_model_and_variables(model_context):
"""
Encrypt the model and variables file, if provided.
:param model_context: the model context object containing the processed command-line arguments
:return: the exit code that should be used to exit the program
"""
_method_name = '__encrypt_model_and_variables'
model_files = cla_utils.get_model_files(model_context.get_model_file())
models = dict()
for model_file in model_files:
try:
models[model_file] = FileToPython(model_file, True).parse()
except TranslateException, te:
__logger.severe('WLSDPLY-04206', _program_name, model_file, te.getLocalizedMessage(), error=te,
class_name=_class_name, method_name=_method_name)
return CommandLineArgUtil.PROG_ERROR_EXIT_CODE
def __perform_model_file_validation(model_file_name, model_context):
"""
:param model_file_name:
:param model_context:
:return:
:raises ValidationException:
"""
_method_name = '__perform_model_file_validation'
print_usage = model_context.get_print_usage()
__logger.entering(model_file_name,
class_name=_class_name,
method_name=_method_name)
try:
model_dictionary = FileToPython(model_file_name.getAbsolutePath(),
True).parse()
model_validator = Validator(model_context, logger=__logger)
validation_results = model_validator.validate_in_standalone_mode(
model_dictionary, model_context.get_variable_file(),
model_context.get_archive_file_name())
except TranslateException, te:
__logger.severe('WLSDPLY-20009',
_program_name,
model_file_name.getAbsolutePath(),
te.getLocalizedMessage(),
error=te,
class_name=_class_name,
method_name=_method_name)
ex = exception_helper.create_validate_exception(
te.getLocalizedMessage(), error=te)
__logger.throwing(ex, class_name=_class_name, method_name=_method_name)
raise ex
def testCompareModelFull3(self):
_method_name = 'testCompareModelFull3'
# This test for
# 1. Changing MailSessionProperty
# 2. Changing ODL HandlerDefaults
# 3. Changing ODL Handler property
# 4. Changing ODL Logger attributes
_variables_file = self._resources_dir + '/compare_model_model1.10.properties'
_new_model_file = self._resources_dir + '/compare_model_model8.yaml'
_old_model_file = self._resources_dir + '/compare_model_model7.yaml'
_temp_dir = os.path.join(tempfile.gettempdir(), _method_name)
if os.path.exists(_temp_dir):
shutil.rmtree(_temp_dir)
os.mkdir(_temp_dir)
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-variable_file': _variables_file,
'-output_dir': _temp_dir,
'-domain_type': 'WLS',
'-trailing_arguments': [_new_model_file, _old_model_file]
}
try:
model_context = ModelContext('CompareModelTestCase', args_map)
obj = ModelFileDiffer(_new_model_file, _old_model_file,
model_context, _temp_dir)
return_code = obj.compare()
self.assertEqual(return_code, 0)
yaml_result = _temp_dir + os.sep + 'diffed_model.yaml'
json_result = _temp_dir + os.sep + 'diffed_model.json'
stdout_result = obj.get_compare_msgs()
model_dictionary = FileToPython(yaml_result).parse()
yaml_exists = os.path.exists(yaml_result)
json_exists = os.path.exists(json_result)
self.assertEqual(yaml_exists, True)
self.assertEqual(json_exists, True)
self.assertEqual(len(stdout_result), 0)
self.assertEqual(model_dictionary.has_key('resources'), True)
self.assertEqual(
model_dictionary['resources'].has_key('MailSession'), True)
self.assertEqual(
model_dictionary['resources']['MailSession'].has_key(
'MyMailSession'), True)
mail_session = model_dictionary['resources']['MailSession'][
'MyMailSession']
self.assertEqual(mail_session.has_key('Properties'), True)
self.assertEqual(
mail_session['Properties'].has_key('mail.imap.port'), True)
self.assertEqual(mail_session['Properties']['mail.imap.port'], 993)
self.assertEqual(
model_dictionary['resources'].has_key('ODLConfiguration'),
True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration'].has_key(
'config'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']
['config'].has_key('HandlerDefaults'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['HandlerDefaults'].has_key('maxFileSize'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['HandlerDefaults']['maxFileSize'], 14857620)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']
['config'].has_key('Handler'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Handler'].has_key('odl-handler'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Handler']['odl-handler'].has_key('Properties'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Handler']['odl-handler']['Properties'].has_key(
'maxFileSize'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Handler']['odl-handler']['Properties']['maxFileSize'],
14857620)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']
['config'].has_key('Logger'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Logger'].has_key(
'oracle.communications.ordermanagement.automation.plugin.AutomationPluginManager'
), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Logger']
['oracle.communications.ordermanagement.automation.plugin.AutomationPluginManager']
.has_key('Level'), True)
self.assertEqual(
model_dictionary['resources']['ODLConfiguration']['config']
['Logger']
['oracle.communications.ordermanagement.automation.plugin.AutomationPluginManager']
['Level'], 'TRACE:16')
self.assertEqual(
len(model_dictionary['resources']['ODLConfiguration']
['config']), 3)
self.assertEqual(
len(model_dictionary['resources']['ODLConfiguration']['config']
['Logger']), 1)
self.assertEqual(
len(model_dictionary['resources']['ODLConfiguration']['config']
['HandlerDefaults']), 1)
except (CompareException, PyWLSTException), te:
return_code = 2
self._logger.severe('WLSDPLY-05709',
te.getLocalizedMessage(),
error=te,
class_name=self._program_name,
method_name=_method_name)
def setUp(self):
self.name = VariableFileHelperTest
self._model = FileToPython(self._model_file).parse()
self._helper = VariableInjector(self.name, self._model, None,
'12.2.1.3')
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._aliases, "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._aliases, 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
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)
__clean_up_temp_files()
# create a minimal model for summary logging
model_context = ModelContext(_program_name, dict())
tool_exit.end(model_context, exit_code)
model_file = model_context.get_model_file()
try:
model_dictionary = FileToPython(model_file, True).parse()
except TranslateException, te:
__logger.severe('WLSDPLY-09014',
_program_name,
model_file,
te.getLocalizedMessage(),
error=te,
class_name=_class_name,
method_name=_method_name)
__clean_up_temp_files()
tool_exit.end(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
try:
variable_map = {}
if model_context.get_variable_file():
variable_map = variables.load_variables(
model_context = __process_args(args)
except CLAException, ex:
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)
__clean_up_temp_files()
tool_exit.end(None, exit_code)
model_file = model_context.get_model_file()
try:
model = FileToPython(model_file, True).parse()
except TranslateException, te:
__logger.severe('WLSDPLY-20009',
_program_name,
model_file,
te.getLocalizedMessage(),
error=te,
class_name=_class_name,
method_name=_method_name)
__clean_up_temp_files()
tool_exit.end(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE)
try:
variable_map = {}
if model_context.get_variable_file():
variable_map = variables.load_variables(
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
def testCompareModel4(self):
_method_name = 'testCompareModel4'
_models_dir = self._resources_dir + '/compare'
_new_model_file = _models_dir + '/model-4-new.yaml'
_old_model_file = _models_dir + '/model-4-old.yaml'
_output_dir = os.path.join(self._results_dir, 'model-4')
if not os.path.isdir(_output_dir):
os.mkdir(_output_dir)
args_map = {
'-oracle_home': '/oracle',
'-output_dir': _output_dir,
'-trailing_arguments': [_new_model_file, _old_model_file]
}
try:
model_context = ModelContext('CompareModelTestCase', args_map)
differ = ModelFileDiffer(_new_model_file, _old_model_file,
model_context, _output_dir)
return_code = differ.compare()
self.assertEqual(return_code, 0)
yaml_result = _output_dir + os.sep + 'diffed_model.yaml'
self.assertEqual(os.path.exists(yaml_result), True,
"YAML result should exist: " + yaml_result)
json_result = _output_dir + os.sep + 'diffed_model.json'
self.assertEqual(os.path.exists(json_result), True,
"JSON result should exist: " + json_result)
# see comments in the model for erased attributes
messages = differ.get_compare_msgs()
self.assertEqual(len(messages), 2)
model_root = FileToPython(yaml_result).parse()
# topology section not present, since no Server differences
topology = dictionary_utils.get_element(model_root, TOPOLOGY)
self.assertEqual(topology, None, "topology should not be present")
resources = dictionary_utils.get_dictionary_element(
model_root, RESOURCES)
# the SelfTuning should contain delete keys for nested, named folders
self_tuning = dictionary_utils.get_dictionary_element(
resources, SELF_TUNING)
work_manager = dictionary_utils.get_dictionary_element(
self_tuning, WORK_MANAGER)
delete_name = model_helper.get_delete_name('newWM')
self.assertEqual(delete_name in work_manager, True,
WORK_MANAGER + ' should contain ' + delete_name)
min_constraint = dictionary_utils.get_dictionary_element(
self_tuning, MIN_THREADS_CONSTRAINT)
delete_name = model_helper.get_delete_name('SampleMinThreads')
self.assertEqual(
delete_name in min_constraint, True,
MIN_THREADS_CONSTRAINT + ' should contain ' + delete_name)
max_constraint = dictionary_utils.get_dictionary_element(
self_tuning, MAX_THREADS_CONSTRAINT)
delete_name = model_helper.get_delete_name('SampleMaxThreads')
self.assertEqual(
delete_name in max_constraint, True,
MAX_THREADS_CONSTRAINT + ' should contain ' + delete_name)
deployments = dictionary_utils.get_dictionary_element(
model_root, APP_DEPLOYMENTS)
libraries = dictionary_utils.get_dictionary_element(
deployments, LIBRARY)
# mylib should not appear in change model, it had no changes
self.assertEqual(len(libraries), 1,
"only one entry should be present in " + LIBRARY)
# retarget should have a source path in change model, even though only targeting changed
retarget = dictionary_utils.get_dictionary_element(
libraries, 'retarget')
self.assertEqual(
SOURCE_PATH in retarget, True,
LIBRARY + ' retarget should contain ' + SOURCE_PATH)
applications = dictionary_utils.get_dictionary_element(
deployments, APPLICATION)
# myapp should not appear in change model, it had no changes
self.assertEqual(
len(applications), 1,
"only one entry should be present in " + APPLICATION)
# retarget should have a source path in change model, even though only targeting changed
retarget = dictionary_utils.get_dictionary_element(
applications, 'retarget')
self.assertEqual(
SOURCE_PATH in retarget, True,
APPLICATION + ' retarget should contain ' + SOURCE_PATH)
except (CompareException, PyWLSTException), te:
return_code = 2
self._logger.severe('WLSDPLY-05709',
te.getLocalizedMessage(),
error=te,
class_name=self._program_name,
method_name=_method_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 testCompareModelFull2(self):
_method_name = 'testCompareModelFull2'
# This test for
# 1. Changing weblogic password
# 2. Changing RCU password
# 3. Deleting an application
_variables_file = self._resources_dir + '/compare_model_model1.10.properties'
_new_model_file = self._resources_dir + '/compare_model_model7.yaml'
_old_model_file = self._resources_dir + '/compare_model_model6.yaml'
_temp_dir = os.path.join(tempfile.gettempdir(), _method_name)
if os.path.exists(_temp_dir):
shutil.rmtree(_temp_dir)
os.mkdir(_temp_dir)
mw_home = os.environ['MW_HOME']
args_map = {
'-oracle_home': mw_home,
'-variable_file': _variables_file,
'-output_dir': _temp_dir,
'-domain_type': 'WLS',
'-trailing_arguments': [_new_model_file, _old_model_file]
}
try:
model_context = ModelContext('CompareModelTestCase', args_map)
obj = ModelFileDiffer(_new_model_file, _old_model_file,
model_context, _temp_dir)
return_code = obj.compare()
self.assertEqual(return_code, 0)
yaml_result = _temp_dir + os.sep + 'diffed_model.yaml'
json_result = _temp_dir + os.sep + 'diffed_model.json'
stdout_result = obj.get_compare_msgs()
model_dictionary = FileToPython(yaml_result).parse()
yaml_exists = os.path.exists(yaml_result)
json_exists = os.path.exists(json_result)
self.assertEqual(yaml_exists, True)
self.assertEqual(json_exists, True)
self.assertEqual(len(stdout_result), 0)
self.assertEqual(model_dictionary.has_key('domainInfo'), True)
self.assertEqual(
model_dictionary['domainInfo'].has_key('AdminPassword'), True)
self.assertEqual(model_dictionary['domainInfo']['AdminPassword'],
'welcome2')
self.assertEqual(
model_dictionary['domainInfo'].has_key('AdminUser'), False)
self.assertEqual(
model_dictionary['domainInfo'].has_key('RCUDbInfo'), True)
self.assertEqual(
model_dictionary['domainInfo']['RCUDbInfo'].has_key(
'rcu_admin_password'), True)
self.assertEqual(len(model_dictionary['domainInfo']['RCUDbInfo']),
1)
self.assertEqual(len(model_dictionary['domainInfo']), 2)
self.assertEqual(model_dictionary.has_key('appDeployments'), True)
self.assertEqual(
model_dictionary['appDeployments'].has_key('Application'),
True)
self.assertEqual(
model_dictionary['appDeployments']['Application'].has_key(
'!yourear'), True)
self.assertEqual(
len(model_dictionary['appDeployments']['Application']), 1)
except (CompareException, PyWLSTException), te:
return_code = 2
self._logger.severe('WLSDPLY-05709',
te.getLocalizedMessage(),
error=te,
class_name=self._program_name,
method_name=_method_name)