def test_config_uri_in_command_line_args(self): """Flags should recognize --config-uri flag to read additional parameters from a JSON dictionary at the given uri. Parameters on the command-line argument list before the --config-uri flag are overridden by values in the --config-uri JSON. Parameters after the --config-uri flag override values from the JSON config. """ with tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8") as fp: config_parameters = dict( int="9", bool="yes", str_value="string", unparsed="foo", delimited_list=["a", "b"], list="3", ) fp.write(base.json_encode(config_parameters, pretty=True)) fp.flush() self.flags.parse( ("--int=7 --list=1 --list=2 --config=file:%s --bool=no " "--delimited_list=c,d " % fp.name) .split() ) self.assertEqual(9, self.flags.int) self.assertEqual(False, self.flags.bool) self.assertEqual("string", self.flags.str_value) self.assertListEqual(["1", "2", "3"], self.flags.list) self.assertListEqual(["a", "b", "c", "d"], self.flags.delimited_list) self.assertGreater( len(self.flags.get_unparsed()), 0, "There should still be unparsed data from the config file: {}".format( self.flags.get_unparsed() ) )
def _write_to_file(config, path): """Writes the configuration to the config file. Args: config: The configuration dictionary. path: Path of the file to write to. """ if os.path.exists(path): backup = '%s.backup.%d' % (path, base.now_ms()) os.rename(path, backup) os.chmod(path=backup, mode=0o600) logging.debug('Writing configuration to file: %r', path) os.makedirs(os.path.dirname(path), exist_ok=True) with open(path, 'wt') as f: json = base.json_encode(config) f.write(json) os.chmod(path=path, mode=0o600)
def test_parse_config_uri_parameter_for_child(self): """Unparsed flags read in a JSON config uri should be available to child_flags.parse.""" with tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8") as f: f.write( base.json_encode( dict( child_int=1, child_bool=False, child_list=["a", "b", "c"] ), pretty=True)) f.flush() self.flags.parse([], config_uri="file:" + f.name) self.child_flags.parse(self.flags.get_unparsed()) self.assertEqual(1, self.child_flags.child_int) self.assertEqual(False, self.child_flags.child_bool) self.assertListEqual(["a", "b", "c"], self.child_flags.child_list)
def test_parse_config_uri_parameter(self): """Flags should be able to read parameters from a JSON config uri.""" with tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8") as f: f.write( base.json_encode( { "int": "09", "str-value": "string", "bool": "True", "list": ["a", "b", "c"], "delimited-list": "1, 2, 3", }, pretty=True)) f.flush() self.flags.parse([], config_uri="file:" + f.name) self.assertEqual(9, self.flags.int) self.assertEqual(True, self.flags.bool) self.assertEqual("string", self.flags.str_value) self.assertListEqual(["a", "b", "c"], self.flags.list) self.assertListEqual(["1", "2", "3"], self.flags.delimited_list)
def test_get_unparsed(self): """get_unparsed() should return string representation of arguments.""" with tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8") as fp: config_parameters = { "unparsed_str": "abc", "unparsed-list": ["a", "b", "c"], } fp.write(base.json_encode(config_parameters, pretty=True)) fp.flush() self.flags.parse( ("unparsed --config=file:%s --unparsed-int=1" % fp.name).split() ) unparsed = self.flags.get_unparsed() self.assertEqual("unparsed", unparsed[0]) self.assertEqual("--unparsed-int=1", unparsed[-1]) self.assertGreater( len(unparsed), 2, "there should be at least one command-line argument for missing value from config: {}" .format(unparsed) )
def test_config_uri_in_command_line_args_for_child(self): """Unparsed flags on the command line and config file should be passed to the child flags object in their original order. """ with tempfile.NamedTemporaryFile(mode="wt", encoding="utf-8") as fp: config_parameters = dict( child_int="9", child_list=["b", "c"], ) fp.write(base.json_encode(config_parameters, pretty=True)) fp.flush() self.flags.parse( ( "--child-int=8 --child-list=a --config=file:%s --child_bool=no --child-list=d" % fp.name ).split() ) self.child_flags.parse(self.flags.get_unparsed()) self.assertEqual(9, self.child_flags.child_int) self.assertEqual(False, self.child_flags.child_bool) self.assertListEqual(["a", "b", "c", "d"], self.child_flags.child_list)
def main(args): conf = Configuration.Get() print(base.json_encode(conf._config)) conf.Write()
def run(self, args): assert (len(args) == 0), "Unexpected launcher command-line arguments: {!r}".format(args) assert os.path.exists(self.flags.java_path), \ "JVM executable not found: {!r}".format(self.flags.java_path) self.extract() # Identify which profile to use: profiles = self.config["profiles"] if self.flags.profile is not None: # Profile explicitly specified by user must exist: assert (self.flags.profile in profiles), \ "Invalid profile {!r}, use one of {}." \ .format(self.flags.profile, sorted(profiles.keys())) profile_name = self.flags.profile else: # No explicit override, default is to use the program name if possible, # falling back to the configured default profile if needed. profile_name = base.get_program_name() if profile_name not in profiles: profile_name = self.config["default_profile"] profile = profiles[profile_name] # Compute the JVM arguments from explicit extension/overrides and from global map: jvm_args = list() if not self.flags.ignore_profile_jvm_args: jvm_args.extend(profile.get("jvm_args", tuple())) jvm_args.extend(arg_map[JVM_ARGS]) # Recover program arguments from global map: program_args = arg_map[PROGRAM_ARGS] # Compute concrete classpath and set environment CLASSPATH accordingly: cp_entries = tuple(self.make_classpath_entries(profile)) env = dict(os.environ) env["CLASSPATH"] = ":".join(cp_entries) # Handle --print-X launcher commands: should_exit = False # becomes true if a special command is invoked (eg. --print-foo) if self.flags.print_classpath: print(":".join(cp_entries)) should_exit = True if self.flags.print_config: print(base.json_encode(self.config)) should_exit = True if should_exit: return os.EX_OK # Determine which Java class to invoke: class_name = profile["main_class"] if self.flags.class_name is not None: class_name = self.flags.class_name log.info("Using Java executable: {!r}", self.flags.java_path) log.info("Using JVM arguments: {!r}", jvm_args) log.info("Using Java main class: {!r}", class_name) log.info("Using classpath: {}", base.json_encode(cp_entries)) log.info("Using Java program arguments: {!r}", program_args) log.debug("Using environment: {}", base.json_encode(env)) args = list() args.append(self.flags.java_path) args.extend(jvm_args) args.append(class_name) args.extend(program_args) os.execve(self.flags.java_path, args, env)