def _apply_filter_and_inject_variable(self, model, model_context, validator):
"""
Applying filter
Generate k8s create script
Inject variable for tokens
:param model: updated model
"""
_method_name = '_apply_filter_and_inject_variable'
self._logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model, "discover", model_context):
self._logger.info('WLSDPLY-06014', _class_name=_class_name, method_name=_method_name)
variable_injector = VariableInjector(_program_name, model, model_context,
WebLogicHelper(self._logger).get_actual_weblogic_version(), self.cache)
if self.cache is not None:
# Generate k8s create secret script, after that clear the dictionary to avoid showing up in the variable file
if model_context.is_targetted_config():
for item in self.cache:
self.secrets_to_generate.add(item)
self.cache.clear()
# This is in case the user has specify -variable_file in command line
# clearing the cache will remove the original entries and the final variable file will miss the original
# contents
if os.path.exists(self.model_context.get_variable_file()):
variable_map = validator.load_variables(self.model_context.get_variable_file())
self.cache.update(variable_map)
variable_injector.inject_variables_keyword_file()
return model
def _apply_filter_and_inject_variable(self, model, model_context):
"""
Applying filter
Inject variable for tokens
:param model: updated model
"""
_method_name = '_apply_filter_and_inject_variable'
self._logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model, "discover", model_context):
self._logger.info('WLSDPLY-06014', _class_name=_class_name, method_name=_method_name)
# include credential properties in the injector map, unless target uses credential secrets
target_config = model_context.get_target_configuration()
if target_config.uses_credential_secrets():
credential_properties = {}
else:
credential_properties = self.credential_injector.get_variable_cache()
variable_injector = VariableInjector(_program_name, model, model_context,
WebLogicHelper(self._logger).get_actual_weblogic_version(),
credential_properties)
# update the variable file with any new values
inserted, variable_model, variable_file_name = \
variable_injector.inject_variables_keyword_file(VARIABLE_FILE_UPDATE)
# return variable_model - if writing the variables file failed, this will be the original model.
# a warning is issued in inject_variables_keyword_file() if that was the case.
return variable_model
def __check_and_customize_model(model, model_context, aliases,
password_injector):
"""
Customize the model dictionary before persisting. Validate the model after customization for informational
purposes. Any validation errors will not stop the discovered model to be persisted.
:param model: completely discovered model, before any tokenization
:param model_context: configuration from command-line
:param aliases: used for validation if model changes are made
:param password_injector: injector created to collect and tokenize passwords, possibly None
"""
_method_name = '__check_and_customize_model'
__logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model.get_model(), "discover",
model_context):
__logger.info('WLSDPLY-06014',
_class_name=_class_name,
method_name=_method_name)
cache = None
if password_injector is not None:
cache = password_injector.get_variable_cache()
# Generate k8s create secret script, possibly using lax validation method
if model_context.is_targetted_config():
validation_method = model_context.get_target_configuration(
).get_validation_method()
model_context.set_validation_method(validation_method)
target_configuration_helper.generate_k8s_script(
model_context, cache, model.get_model())
# if target handles password substitution, clear property cache to keep out of variables file.
if model_context.get_target_configuration().manages_credentials():
cache.clear()
# Apply the injectors specified in model_variable_injector.json, or in the target configuration
variable_injector = VariableInjector(
_program_name, model.get_model(), model_context,
WebLogicHelper(__logger).get_actual_weblogic_version(), cache)
inserted, variable_model, variable_file_name = variable_injector.inject_variables_keyword_file(
)
if inserted:
model = Model(variable_model)
try:
validator = Validator(model_context,
wlst_mode=__wlst_mode,
aliases=aliases)
# no variables are generated by the discover tool
validator.validate_in_tool_mode(
model.get_model(),
variables_file_name=variable_file_name,
archive_file_name=model_context.get_archive_file_name())
except ValidateException, ex:
__logger.warning('WLSDPLY-06015',
ex.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
def get_variable_name(self, attribute_location, attribute, suffix=None):
"""
Override method to possibly create secret token names instead of property names.
:param attribute_location: the location to be used
:param attribute: the attribute to be examined
:param suffix: optional suffix for name
:return: the derived name, such as jdbc-generic1.password
"""
aliases = self.get_aliases()
target_config = self._model_context.get_target_configuration()
# domainInfo attributes have separate model and attribute locations
model_location = attribute_location
if model_location.get_current_model_folder() == DOMAIN_INFO_ALIAS:
model_location = LocationContext()
if target_config.uses_credential_secrets():
# use the secret token name as variable name in the cache, such as jdbc-generic1.password .
# secret name is the adjusted variable name, with the last element replaced with "username" or "password".
attribute_type = aliases.get_model_attribute_type(attribute_location, attribute)
variable_name = VariableInjector.get_variable_name(self, model_location, attribute)
secret_name = target_configuration_helper.create_secret_name(variable_name, suffix)
secret_key = SECRET_USERNAME_KEY
if attribute_type == PASSWORD:
secret_key = SECRET_PASSWORD_KEY
# suffix such as map3.password in MailSession properties
if suffix and suffix.endswith(".password"):
secret_key = SECRET_PASSWORD_KEY
return '%s:%s' % (secret_name, secret_key)
return VariableInjector.get_variable_name(self, model_location, attribute, suffix=suffix)
def __init__(self, program_name, model, model_context, version=None, variable_dictionary=None):
"""
Construct an instance of the credential 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
:param variable_dictionary: optional, a pre-populated map of variables
"""
VariableInjector.__init__(self, program_name, model, model_context, version=version,
variable_dictionary=variable_dictionary)
self._model_context = model_context
def __check_and_customize_model(model, model_context, aliases):
"""
Customize the model dictionary before persisting. Validate the model after customization for informational
purposes. Any validation errors will not stop the discovered model to be persisted.
:param model: completely discovered model
"""
_method_name = '__check_and_customize_model'
__logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model.get_model(), "discover"):
__logger.info('WLSDPLY-06014',
_class_name=_class_name,
method_name=_method_name)
inserted, variable_model, variable_file_name = VariableInjector(_program_name, model.get_model(), model_context,
WebLogicHelper(
__logger).get_actual_weblogic_version()).\
inject_variables_keyword_file()
if inserted:
model = Model(variable_model)
try:
validator = Validator(model_context,
wlst_mode=__wlst_mode,
aliases=aliases)
# no variables are generated by the discover tool
validator.validate_in_tool_mode(
model.get_model(),
variables_file_name=variable_file_name,
archive_file_name=model_context.get_archive_file_name())
except ValidateException, ex:
__logger.warning('WLSDPLY-06015',
ex.getLocalizedMessage(),
class_name=_class_name,
method_name=_method_name)
def __inject(model, model_context):
"""
Inject variables into the model file that is loaded into the model_context.
:param model_context: the model context
:return: True if variables were inserted into model: The updated model
"""
version = WebLogicHelper(__logger).get_actual_weblogic_version()
injector = VariableInjector(_program_name, model, model_context, version)
inserted, variable_model, variable_file_name =\
injector.inject_variables_keyword_file(append_option=variable_injector.VARIABLE_FILE_UPDATE)
if inserted:
model = Model(variable_model)
return inserted, model
def __check_and_customize_model(model, model_context, aliases, injector):
"""
Customize the model dictionary before persisting. Validate the model after customization for informational
purposes. Any validation errors will not stop the discovered model to be persisted.
:param model: completely discovered model
"""
_method_name = '__check_and_customize_model'
__logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model.get_model(), "discover", model_context):
__logger.info('WLSDPLY-06014', _class_name=_class_name, method_name=_method_name)
cache = None
if injector is not None:
cache = injector.get_variable_cache()
# Generate k8s create secret script, after that clear the dictionary to avoid showing up in the variable file
if model_context.is_targetted_config():
validation_method = model_context.get_target_configuration()['validation_method']
model_context.set_validation_method(validation_method)
target_configuration_helper.generate_k8s_script(model_context.get_kubernetes_variable_file(), cache)
cache.clear()
variable_injector = VariableInjector(_program_name, model.get_model(), model_context,
WebLogicHelper(__logger).get_actual_weblogic_version(), cache)
inserted, variable_model, variable_file_name = \
variable_injector.inject_variables_keyword_file()
if inserted:
model = Model(variable_model)
try:
validator = Validator(model_context, wlst_mode=__wlst_mode, aliases=aliases)
# no variables are generated by the discover tool
validator.validate_in_tool_mode(model.get_model(), variables_file_name=variable_file_name,
archive_file_name=model_context.get_archive_file_name())
except ValidateException, ex:
__logger.warning('WLSDPLY-06015', ex.getLocalizedMessage(), class_name=_class_name, method_name=_method_name)
def __inject(model, model_context):
"""
Inject variables into the model file that is loaded into the model_context.
:param model_context: the model context
:return: True if variables were inserted into model: The updated model
"""
__kwargs[variable_injector.VARIABLE_FILE_APPEND_ARG] = variable_injector.VARIABLE_FILE_UPDATE
inserted, variable_model, variable_file_name = VariableInjector(_program_name, model, model_context,
WebLogicHelper(
__logger).get_actual_weblogic_version()). \
inject_variables_keyword_file(**__kwargs)
if inserted:
model = Model(variable_model)
return inserted, model
def get_variable_token(self, attribute, variable_name):
"""
Override method to possibly create secret tokens instead of property token.
:param attribute: the attribute to be examined
:param variable_name: the variable name, such as JDBC.Generic1.PasswordEncrypted
:return: the complete token name, such as @@SECRET:jdbc-generic1.password@@
"""
target_config = self._model_context.get_target_configuration()
credentials_method = target_config.get_credentials_method()
if credentials_method == SECRETS_METHOD:
return target_configuration_helper.format_as_secret_token(variable_name, target_config)
elif credentials_method == CONFIG_OVERRIDES_SECRETS_METHOD:
return target_configuration_helper.format_as_overrides_secret(variable_name)
else:
return VariableInjector.get_variable_token(self, attribute, variable_name)
def __check_and_customize_model(model, model_context, aliases,
credential_injector):
"""
Customize the model dictionary before persisting. Validate the model after customization for informational
purposes. Any validation errors will not stop the discovered model to be persisted.
:param model: completely discovered model, before any tokenization
:param model_context: configuration from command-line
:param aliases: used for validation if model changes are made
:param credential_injector: injector created to collect and tokenize credentials, possibly None
"""
_method_name = '__check_and_customize_model'
__logger.entering(class_name=_class_name, method_name=_method_name)
if filter_helper.apply_filters(model.get_model(), "discover",
model_context):
__logger.info('WLSDPLY-06014',
_class_name=_class_name,
method_name=_method_name)
# target config always present in model context, default config if not declared
target_configuration = model_context.get_target_configuration()
# if target config declared, use the validation method it contains (lax, etc.)
if model_context.is_targetted_config():
validation_method = target_configuration.get_validation_method()
model_context.set_validation_method(validation_method)
credential_cache = None
if credential_injector is not None:
# filter variables or secrets that are no longer in the model
credential_injector.filter_unused_credentials(model.get_model())
credential_cache = credential_injector.get_variable_cache()
# Generate k8s create secret script
if target_configuration.uses_credential_secrets():
target_configuration_helper.generate_k8s_script(
model_context, credential_cache, model.get_model(),
ExceptionType.DISCOVER)
# create additional output after filtering, but before variables have been inserted
if model_context.is_targetted_config():
target_configuration_helper.create_additional_output(
model, model_context, aliases, credential_injector,
ExceptionType.DISCOVER)
# if target handles credential configuration, clear property cache to keep out of variables file.
if model_context.get_target_configuration().manages_credentials():
credential_cache.clear()
# Apply the injectors specified in model_variable_injector.json, or in the target configuration.
# Include the variable mappings that were collected in credential_cache.
variable_injector = VariableInjector(
_program_name, model.get_model(), model_context,
WebLogicHelper(__logger).get_actual_weblogic_version(),
credential_cache)
inserted, variable_model, variable_file_name = variable_injector.inject_variables_keyword_file(
)
if inserted:
model = Model(variable_model)
try:
validator = Validator(model_context,
wlst_mode=__wlst_mode,
aliases=aliases)
# no variables are generated by the discover tool
validator.validate_in_tool_mode(
model.get_model(),
variables_file_name=variable_file_name,
archive_file_name=model_context.get_archive_file_name())
except ValidateException, ex:
__logger.warning('WLSDPLY-06015',
ex.getLocalizedMessage(),
class_name=_class_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')
class VariableFileHelperTest(unittest.TestCase):
_resources_dir = '../../test-classes'
_variable_file = _resources_dir + '/variable.injector.test.properties'
_model_file = _resources_dir + '/variable_insertion.yaml'
_variable_injector_keyword = 'variable_injector_keyword.json'
_keywords_file = 'keywords.json'
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 testSingleVariableReplacement(self):
replacement_dict = dict()
replacement_dict['Machine.NodeManager.ListenAddress'] = dict()
expected = dict()
expected['Machine.machine1.NodeManager.ListenAddress'] = '127.0.0.1'
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testMultiplesReplacement(self):
expected = dict()
expected['Server.AdminServer.SSL.ListenPort'] = '9002'
expected['Server.AdminServer.ListenPort'] = '9001'
expected['Server.m2.ListenPort'] = '9005'
expected['Server.m1.ListenPort'] = '9003'
expected['Server.m1.SSL.ListenPort'] = '9004'
expected['Server.m2.SSL.ListenPort'] = '9006'
expected['JMSSystemResource.MyJmsModule.JmsResource.ForeignServer.MyForeignServer.ConnectionURL'] \
= 't3://my.other.cluster:7001'
expected[
'JMSSystemResource.MyJmsModule.JmsResource.ForeignServer.MyForeignServer.'
'ForeignDestination.MyRemoteQ.LocalJNDIName'] = 'jms/remoteQ'
replacement_dict = dict()
replacement_dict['Server.ListenPort'] = dict()
replacement_dict[
'JMSSystemResource.JmsResource.ForeignServer.ConnectionURL'] = dict(
)
replacement_dict[
'JMSSystemResource.JmsResource.ForeignServer.ForeignDestination.LocalJNDIName'] = dict(
)
replacement_dict['Server.SSL.ListenPort'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testInvalidMBeanNameNoException(self):
expected = dict()
replacement_dict = dict()
replacement_dict['JmsSystemResource.Notes'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testInvalidAttributeName(self):
expected = dict()
replacement_dict = dict()
replacement_dict['Server.listenaddress'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testDomainAttributeReplacementAndModel(self):
expected = dict()
expected['Notes'] = 'Test note replacement'
expected_replacement = '@@PROP:Notes@@'
replacement_dict = dict()
replacement_dict['Notes'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
self.assertEqual(expected_replacement,
self._model['topology']['Notes'])
def testWithSegment(self):
expected = dict()
expected['JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.URL--Host'] = \
'slc05til.us.oracle.com'
expected['JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.URL--Port'] = \
'1521'
replacement_dict = dict()
replacement_dict[
'JDBCSystemResource.JdbcResource.JDBCDriverParams.URL'] = dict()
list_entry1 = dict()
list_entry1[
variable_injector.REGEXP_PATTERN] = '(?<=PORT=)[\w.-]+(?=\))'
list_entry1[variable_injector.REGEXP_SUFFIX] = 'Port'
list_entry2 = dict()
list_entry2[
variable_injector.REGEXP_PATTERN] = '(?<=HOST=)[\w.-]+(?=\))'
list_entry2[variable_injector.REGEXP_SUFFIX] = 'Host'
replacement_dict[
'JDBCSystemResource.JdbcResource.JDBCDriverParams.URL'][
variable_injector.REGEXP] = [list_entry1, list_entry2]
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
db2 = 'jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)' \
'(HOST=@@PROP:JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.URL--Host@@)' \
'(PORT=@@PROP:JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.URL--Port@@)))' \
'(CONNECT_DATA=(SERVICE_NAME=orcl.us.oracle.com)))'
db1 = 'jdbc:oracle:thin:@//den00chv.us.oracle.com:1521/PDBORCL'
self.assertEqual(
db2, self._model['resources']['JDBCSystemResource']['Database2']
['JdbcResource']['JDBCDriverParams']['URL'])
self.assertEqual(
db1, self._model['resources']['JDBCSystemResource']['Database1']
['JdbcResource']['JDBCDriverParams']['URL'])
def testWithSegmentInDictionary(self):
expected = dict()
expected[
'MailSession.MailSession-0.Properties--SmtpHost'] = 'stbeehive.oracle.com'
expected[
'MailSession.MyMailSession.Properties--SmtpHost'] = 'stbeehive.oracle.com'
expected[
'MailSession.MailSession-0.Properties--ImapHost'] = 'stbeehive.oracle.com'
expected[
'MailSession.MyMailSession.Properties--ImapHost'] = 'stbeehive.oracle.com'
replacement_dict = dict()
replacement_dict['MailSession.Properties'] = dict()
list_entry1 = dict()
list_entry1[variable_injector.REGEXP_PATTERN] = 'mail.smtp.host'
list_entry1[variable_injector.REGEXP_SUFFIX] = 'SmtpHost'
list_entry2 = dict()
list_entry2[variable_injector.REGEXP_PATTERN] = 'mail.imap.host'
list_entry2[variable_injector.REGEXP_SUFFIX] = 'ImapHost'
replacement_dict['MailSession.Properties'][
variable_injector.REGEXP] = [list_entry1, list_entry2]
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
self.assertEqual(
'@@PROP:MailSession.MyMailSession.Properties--SmtpHost@@',
self._model['resources']['MailSession']['MyMailSession']
['Properties']['mail.smtp.host'])
self.assertEqual(
'@@PROP:MailSession.MyMailSession.Properties--ImapHost@@',
self._model['resources']['MailSession']['MyMailSession']
['Properties']['mail.imap.host'])
def testWithSegmentInDictionaryAndAPattern(self):
expected = dict()
expected[
'MailSession.MyMailSession.Properties--Host'] = 'stbeehive.oracle.com'
expected[
'MailSession.MailSession-0.Properties--Host'] = 'stbeehive.oracle.com'
replacement_dict = dict()
replacement_dict['MailSession.Properties'] = dict()
list_entry = dict()
list_entry[variable_injector.REGEXP_PATTERN] = '(?<=\w.)host'
list_entry[variable_injector.REGEXP_SUFFIX] = 'Host'
replacement_dict['MailSession.Properties'][
variable_injector.REGEXP] = [list_entry]
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
self.assertEqual(
'@@PROP:MailSession.MyMailSession.Properties--Host@@',
self._model['resources']['MailSession']['MyMailSession']
['Properties']['mail.imap.host'])
self.assertEqual(
'@@PROP:MailSession.MyMailSession.Properties--Host@@',
self._model['resources']['MailSession']['MyMailSession']
['Properties']['mail.host'])
self.assertEqual(
'@@PROP:MailSession.MyMailSession.Properties--Host@@',
self._model['resources']['MailSession']['MyMailSession']
['Properties']['mail.smtp.host'])
def testWithSegmentInList(self):
expected = dict()
expected[
'WLDFSystemResource.MyWldfModule.WLDFResource.Harvester.HarvestedType.weblogic.management.'
'runtime.ServerRuntimeMBean.HarvestedAttribute'] = 'OracleHome'
replacement_dict = dict()
replacement_dict[
'WLDFSystemResource.WLDFResource.Harvester.HarvestedType.HarvestedAttribute'] = dict(
)
list_entry = dict()
list_entry[variable_injector.REGEXP_PATTERN] = 'OracleHome'
replacement_dict[
'WLDFSystemResource.WLDFResource.Harvester.HarvestedType.HarvestedAttribute'][
variable_injector.REGEXP] = [list_entry]
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
wldf_list = self._model['resources']['WLDFSystemResource'][
'MyWldfModule']['WLDFResource']['Harvester']['HarvestedType'][
'weblogic.management.runtime.ServerRuntimeMBean'][
'HarvestedAttribute']
found = False
for entry in wldf_list:
if entry == '@@PROP:WLDFSystemResource.MyWldfModule.WLDFResource.Harvester.HarvestedType.' \
'weblogic.management.runtime.ServerRuntimeMBean.HarvestedAttribute@@':
found = True
break
self.assertEqual(True, found)
def testWithSegmentInStringInList(self):
expected = dict()
expected[
'WLDFSystemResource.MyWldfModule.WLDFResource.Harvester.HarvestedType.weblogic.management.'
'runtime.ServerRuntimeMBean.HarvestedInstance--ManagedServer'] = 'm1'
replacement_dict = dict()
replacement_dict[
'WLDFSystemResource.WLDFResource.Harvester.HarvestedType.HarvestedInstance'] = dict(
)
list_entry = dict()
list_entry[variable_injector.REGEXP_PATTERN] = 'm1'
list_entry[variable_injector.REGEXP_SUFFIX] = 'ManagedServer'
replacement_dict[
'WLDFSystemResource.WLDFResource.Harvester.HarvestedType.HarvestedInstance'][
variable_injector.REGEXP] = [list_entry]
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
wldf_list = self._model['resources']['WLDFSystemResource'][
'MyWldfModule']['WLDFResource']['Harvester']['HarvestedType'][
'weblogic.management.runtime.ServerRuntimeMBean'][
'HarvestedInstance']
found = False
for entry in wldf_list:
if entry == 'com.bea:Name=@@PROP:WLDFSystemResource.MyWldfModule.WLDFResource.Harvester.HarvestedType.' \
'weblogic.management.runtime.ServerRuntimeMBean.HarvestedInstance--ManagedServer@@' \
',Type=ServerRuntime':
found = True
break
self.assertEqual(True, found)
def testWithMBeanName(self):
expected = dict()
expected[
'JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.Properties.user.Value'] = 'sys as dba'
expected[
'JDBCSystemResource.Database1.JdbcResource.JDBCDriverParams.Properties.user.Value'] = 'admin'
replacement_dict = dict()
replacement_dict[
'JDBCSystemResource.JdbcResource.JDBCDriverParams.Properties[user].Value'] = dict(
)
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testWithListMBeanName(self):
expected = dict()
expected['Server.m1.SSL.Enabled'] = 'True'
expected['Server.m2.SSL.Enabled'] = 'True'
replacement_dict = dict()
replacement_dict['Server[m1,m2].SSL.Enabled'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testWithManagedServerKeyword(self):
expected = dict()
expected['Server.m1.SSL.Enabled'] = 'True'
expected['Server.m2.SSL.Enabled'] = 'True'
replacement_dict = dict()
replacement_dict['Server[MANAGED_SERVERS].SSL.Enabled'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testWithMultiKeyword(self):
expected = dict()
expected['Server.AdminServer.SSL.Enabled'] = 'True'
expected['Server.m1.SSL.Enabled'] = 'True'
expected['Server.m2.SSL.Enabled'] = 'True'
replacement_dict = dict()
replacement_dict[
'Server[MANAGED_SERVERS,ADMIN_SERVER].SSL.Enabled'] = dict()
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testWithVariableHelperKeywords(self):
expected = dict()
expected['JMSSystemResource.MyJmsModule.JmsResource.ForeignServer.MyForeignServer.ConnectionURL'] \
= 't3://my.other.cluster:7001'
expected['Server.AdminServer.ListenPort'] = '9001'
expected['Server.m2.ListenPort'] = '9005'
expected['Server.m1.ListenPort'] = '9003'
expected['Machine.machine1.NodeManager.ListenPort'] = '5557'
expected[
'Machine.machine1.NodeManager.PasswordEncrypted'] = '--FIX ME--'
expected['Machine.machine1.NodeManager.UserName'] = '******'
inserted, model, variable_file_name = self._helper.inject_variables_keyword_file(
variable_file_name=self._variable_file,
variable_injector_path_name=self._resources_dir,
variable_injector_file_name=self._variable_injector_keyword,
variable_keywords_path_name=self._resources_dir,
variable_keywords_file_name=self._keywords_file)
self.assertEqual(self._variable_file, variable_file_name)
self.assertEqual(True, inserted)
actual = variables.load_variables(self._variable_file)
self._compare_to_expected_dictionary(expected, actual)
def testForceAttribute(self):
expected = dict()
expected[
'Server.AdminServer.SSL.HostnameVerificationIgnored'] = 'false'
expected['Server.m1.SSL.HostnameVerificationIgnored'] = 'false'
expected['Server.m2.SSL.HostnameVerificationIgnored'] = 'false'
replacement_dict = dict()
replacement_dict['Server.SSL.HostnameVerificationIgnored'] = dict()
replacement_dict['Server.SSL.HostnameVerificationIgnored'][
variable_injector.FORCE] = True
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testForceAttributeWithTwoDefaults(self):
expected = dict()
expected[
'JMSSystemResource.MyJmsModule.JmsResource.Template.JmsTemplate.MaximumMessageSize'] = '0'
replacement_dict = dict()
replacement_dict[
'JMSSystemResource.JmsResource.Template.MaximumMessageSize'] = dict(
)
replacement_dict[
'JMSSystemResource.JmsResource.Template.MaximumMessageSize'][
variable_injector.FORCE] = True
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testReplaceVariableValueAttribute(self):
expected = dict()
expected[
'JMSSystemResource.MyJmsModule.JmsResource.ForeignServer.MyForeignServer.JNDIProperty'
'.java.naming.security.principal.Value'] = 'k8s'
replacement_dict = dict()
replacement_dict[
'JMSSystemResource.JmsResource.ForeignServer.'
'JNDIProperty[java.naming.security.principal].Value'] = dict()
replacement_dict['JMSSystemResource.JmsResource.ForeignServer.'
'JNDIProperty[java.naming.security.principal].Value'][
variable_injector.VARIABLE_VALUE] = 'k8s'
actual = self._helper.inject_variables(replacement_dict)
print actual
self._compare_to_expected_dictionary(expected, actual)
def testReplaceVariableValueSegmentInString(self):
expected = dict()
expected['JDBCSystemResource.Database2.JdbcResource.JDBCDriverParams.URL--Host'] = \
'den00chv'
replacement_dict = dict()
replacement_dict[
'JDBCSystemResource[Database2].JdbcResource.JDBCDriverParams.URL'] = dict(
)
list_entry = dict()
list_entry[
variable_injector.REGEXP_PATTERN] = '(?<=HOST=)[\w.-]+(?=\))'
list_entry[variable_injector.REGEXP_SUFFIX] = 'Host'
replacement_dict[
'JDBCSystemResource[Database2].JdbcResource.JDBCDriverParams.URL'][
variable_injector.REGEXP] = [list_entry]
replacement_dict[
'JDBCSystemResource[Database2].JdbcResource.JDBCDriverParams.URL'][
variable_injector.VARIABLE_VALUE] = 'den00chv'
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def testReplaceVariableValueSegmentInDictionary(self):
expected = dict()
expected[
'MailSession.MailSession-0.Properties--SmtpHost'] = 'localhost'
expected[
'MailSession.MyMailSession.Properties--SmtpHost'] = 'localhost'
replacement_dict = dict()
replacement_dict['MailSession.Properties'] = dict()
list_entry = dict()
list_entry[variable_injector.REGEXP_PATTERN] = 'mail.smtp.host'
list_entry[variable_injector.REGEXP_SUFFIX] = 'SmtpHost'
replacement_dict['MailSession.Properties'][
variable_injector.REGEXP] = [list_entry]
replacement_dict['MailSession.Properties'][
variable_injector.VARIABLE_VALUE] = 'localhost'
actual = self._helper.inject_variables(replacement_dict)
self._compare_to_expected_dictionary(expected, actual)
def _compare_to_expected_dictionary(self, expected, actual):
self.assertEqual(
len(expected), len(actual),
'Not the same number of entries : expected=' + str(len(expected)) +
', actual=' + str(len(actual)))
for k, v in actual.iteritems():
self.assertEqual(
True, k in expected and v == expected[k],
'Actual item not in expected ' + k + ' : ' + v +
' expected=' + str(expected))
__logger.severe('WLSDPLY-06010',
_program_name,
model_context.get_archive_file_name(),
ex.getLocalizedMessage(),
error=ex,
class_name=_class_name,
method_name=_method_name)
__log_and_exit(model_context, CommandLineArgUtil.PROG_ERROR_EXIT_CODE,
_class_name, _method_name)
aliases = Aliases(model_context, wlst_mode=__wlst_mode)
model = None
discover_injector = None
if model_context.get_variable_file() is not None:
discover_injector = VariableInjector(
_program_name, dict(), model_context,
WebLogicHelper(__logger).get_actual_weblogic_version())
__logger.info('WLSDPLY-06025',
class_name=_class_name,
method_name=_method_name)
else:
__logger.info('WLSDPLY-06024',
class_name=_class_name,
method_name=_method_name)
try:
model = __discover(model_context, aliases, discover_injector, helper)
except DiscoverException, ex:
__logger.severe('WLSDPLY-06011',
_program_name,
model_context.get_domain_name(),
def setUp(self):
self.name = 'VariableFileHelperTest'
self._model = FileToPython(self._model_file).parse()
self._model_context = ModelContext(self.name, {})
self._helper = VariableInjector(self.name, self._model,
self._model_context, '12.2.1.3')
