def __process_args(args):
"""
Process the command-line arguments.
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
_method_name = '__process_args'
cla_util = CommandLineArgUtil(_program_name, __required_arguments, __optional_arguments)
argument_map = cla_util.process_args(args, trailing_arg_count=2)
model_context = ModelContext(_program_name, argument_map)
model_context.set_ignore_missing_archive_entries(True)
return model_context
def main(args):
"""
The python entry point for updateDomain.
:param args:
:return:
"""
_method_name = 'main'
__logger.entering(args[0], class_name=_class_name, method_name=_method_name)
for index, arg in enumerate(args):
__logger.finer('sys.argv[{0}] = {1}', str(index), str(arg), class_name=_class_name, method_name=_method_name)
__wlst_helper.silence()
exit_code = CommandLineArgUtil.PROG_OK_EXIT_CODE
try:
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)
cla_helper.clean_up_temp_files()
# create a minimal model for summary logging
model_context = ModelContext(_program_name, dict())
tool_exit.end(model_context, exit_code)
def __process_args(args):
"""
Process the command-line arguments and prompt the user for any missing information
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
cla_util = CommandLineArgUtil(_program_name, __required_arguments,
__optional_arguments)
required_arg_map, optional_arg_map = cla_util.process_args(args, True)
__verify_required_args_present(required_arg_map)
__process_java_home_arg(optional_arg_map)
__process_domain_location_args(optional_arg_map)
__process_model_args(optional_arg_map)
#
# Verify that the domain type is a known type and load its typedef.
#
domain_type = required_arg_map[CommandLineArgUtil.DOMAIN_TYPE_SWITCH]
domain_typedef = DomainTypedef(_program_name, domain_type)
optional_arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] = domain_typedef
__process_rcu_args(optional_arg_map, domain_type, domain_typedef)
__process_encryption_args(optional_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
model_context = ModelContext(_program_name, combined_arg_map)
domain_typedef.set_model_context(model_context)
return model_context
def testPrintUsageRecursive(self):
_method_name = 'testPrintUsageRecursive'
_RECURSIVE = '-recursive'
args = {
'-oracle_home': os.environ['MW_HOME']
}
model_paths = [
'appDeployments:/Application'
]
try:
# Loop through valid list of model sections
for model_path in model_paths:
# Set print usage context
args['-print_usage'] = '%s %s' % (model_path, _RECURSIVE)
self._logger.info('args={0}', str(args), class_name=self._class_name, method_name=_method_name)
model_context = ModelContext(self._program_name, args)
model_validator = Validator(model_context, wlst_mode=WlstModes.ONLINE)
model_validator.print_usage(model_path)
self.assertEquals(True, True)
except ValidateException, ve:
self.fail(ve.getLocalizedMessage())
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 testCompareModelInvalidModel(self):
_method_name = 'testCompareModelInvalidModel'
_variables_file = self._resources_dir + '/compare_model_model1.10.properties'
_new_model_file = self._resources_dir + '/compare_model_model3.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()
except (CompareException, PyWLSTException), te:
return_code = 2
def __process_args(args):
"""
Process the command-line arguments and prompt the user for any missing information
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
global __wlst_mode
cla_util = CommandLineArgUtil(_program_name, __required_arguments,
__optional_arguments)
required_arg_map, optional_arg_map = cla_util.process_args(args)
domain_type = dictionary_utils.get_element(
optional_arg_map, CommandLineArgUtil.DOMAIN_TYPE_SWITCH)
if domain_type is None:
domain_type = 'WLS'
domain_typedef = DomainTypedef(_program_name, domain_type)
optional_arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] = domain_typedef
__verify_required_args_present(required_arg_map)
__wlst_mode = __process_online_args(optional_arg_map)
__process_archive_filename_arg(required_arg_map)
__process_variable_filename_arg(optional_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
return ModelContext(_program_name, combined_arg_map)
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
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 testPrintUsageFoldersOnly(self):
_method_name = 'testPrintUsageFoldersOnly'
_FOLDERS_ONLY = '-folders_only'
args = {
'-oracle_home': os.environ['MW_HOME']
}
model_paths = [
'resources:/FileStore'
]
try:
# Loop through valid list of model sections
for model_path in model_paths:
# Set print usage context
args['-print_usage'] = '%s %s' % (model_path, _FOLDERS_ONLY)
self._logger.info('args={0}', str(args), class_name=self._class_name, method_name=_method_name)
model_context = ModelContext(self._program_name, args)
model_validator = Validator(model_context, wlst_mode=WlstModes.ONLINE)
model_validator.print_usage(model_path)
self.assertEquals(True, True)
except ValidateException, ve:
self.fail(ve.getLocalizedMessage())
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 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 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", {})
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 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 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 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 __process_args(args, logger):
"""
Process the command-line arguments.
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
_method_name = '__process_args'
cla_util = CommandLineArgUtil(_program_name, __required_arguments, __optional_arguments)
argument_map = cla_util.process_args(args)
__process_target_arg(argument_map, logger)
return ModelContext(_program_name, argument_map)
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 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 __process_args(args):
"""
Process the command-line arguments.
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
_method_name = '__process_args'
cla_util = CommandLineArgUtil(_program_name, __required_arguments,
__optional_arguments)
cla_util.set_allow_multiple_models(True)
argument_map = cla_util.process_args(args)
target_configuration_helper.process_target_arguments(argument_map)
return ModelContext(_program_name, argument_map)
def create_context(program_name, combined_arg_map, domain_typedef=None):
"""
Create a model context object from the specified argument map, with the domain typedef set up correctly.
If the domain_typedef is not specified, construct it from the argument map.
:param program_name: the program name, used for logging
:param combined_arg_map: all the arguments passed to the program
:param domain_typedef: a domain typedef object to be used, or None
:return: the new model context object
"""
if domain_typedef is None:
domain_typedef = create_typedef(program_name, combined_arg_map)
combined_arg_map[CommandLineArgUtil.DOMAIN_TYPEDEF] = domain_typedef
model_context = ModelContext(program_name, combined_arg_map)
domain_typedef.set_model_context(model_context)
return model_context
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 _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())
def __process_args(args):
"""
Process the command-line arguments and prompt the user for any missing information
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
cla_util = CommandLineArgUtil(_program_name, __required_arguments, __optional_arguments)
cla_util.set_allow_multiple_models(True)
required_arg_map, optional_arg_map = cla_util.process_args(args)
__verify_required_args_present(required_arg_map)
__process_model_args(optional_arg_map)
__process_print_usage_args(optional_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
return ModelContext(_program_name, combined_arg_map)
def testCompareModel5(self):
_method_name = 'testCompareModel5'
_models_dir = self._resources_dir + '/compare'
_new_model_file = _models_dir + '/model-4-new.yaml'
_old_model_file = _models_dir + '/model-4-new.yaml'
_output_dir = os.path.join(self._results_dir, 'model-5')
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), False,
"YAML result should not exist: " + yaml_result)
json_result = _output_dir + os.sep + 'diffed_model.json'
self.assertEqual(os.path.exists(json_result), False,
"JSON result should not exist: " + json_result)
json_result = _output_dir + os.sep + 'compare_model_stdout'
self.assertEqual(
os.path.exists(json_result), False,
"compare_model.stdout result should not exist: " + json_result)
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 testCompareModelInvalidFile(self):
_method_name = 'testCompareModelInvalidFile'
_variables_file = self._resources_dir + '/compare_model_model1.10.properties'
_new_model_file = self._resources_dir + '/compare_model_model4.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)
# expected parse error for model4, disable logging
yaml_logger = PlatformLogger('wlsdeploy.yaml')
yaml_level = yaml_logger.get_level()
yaml_logger.set_level(Level.OFF)
compare_logger = PlatformLogger('wlsdeploy.compare_model')
compare_level = compare_logger.get_level()
compare_logger.set_level(Level.OFF)
return_code = obj.compare()
# Restore original log levels
yaml_logger.set_level(yaml_level)
compare_logger.set_level(compare_level)
except (CompareException, PyWLSTException), te:
return_code = 2
def __process_args(args):
"""
Process the command-line arguments and prompt the user for any missing information
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
global __wlst_mode
cla_util = CommandLineArgUtil(_program_name, __required_arguments, __optional_arguments)
required_arg_map, optional_arg_map = cla_util.process_args(args)
__process_model_args(optional_arg_map)
__process_injector_file(optional_arg_map)
__process_keywords_file(optional_arg_map)
__process_properties_file(optional_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
return ModelContext(_program_name, combined_arg_map)
def __process_args(args):
"""
Process the command-line arguments.
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
_method_name = '__process_args'
cla_util = CommandLineArgUtil(_program_name, __required_arguments,
__optional_arguments)
required_arg_map, optional_arg_map = cla_util.process_args(
args, trailing_arg_count=2)
cla_helper.verify_required_args_present(_program_name,
__required_arguments,
required_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
return ModelContext(_program_name, combined_arg_map)
def __process_args(args):
"""
Process the command-line arguments and prompt the user for any missing information
:param args: the command-line arguments list
:raises CLAException: if an error occurs while validating and processing the command-line arguments
"""
global __wlst_mode
cla_util = CommandLineArgUtil(_program_name, __required_arguments,
__optional_arguments)
required_arg_map, optional_arg_map = cla_util.process_args(args)
__verify_required_args_present(required_arg_map)
__wlst_mode = __process_online_args(optional_arg_map)
__process_archive_filename_arg(required_arg_map)
__process_variable_filename_arg(optional_arg_map)
combined_arg_map = optional_arg_map.copy()
combined_arg_map.update(required_arg_map)
return ModelContext(_program_name, combined_arg_map)
