Dynamically call other commands from a command

[rsenden]

What's the best way to dynamically call other commands from a Picocli command implementation?

Suppose I have a sub-command named run that reads a YAML file containing instructions like the following:

- cmd: subcmd1 subcmd2 --arg1 xyz

When encountering the cmd property above, I'd like to execute the given sub-command and retrieve it's output and exit code.

The following pseudocode seems to work for basic invocation (not explicitly handling command output yet), but not sure whether this is the best approach and whether this may cause any side-effects.

@Command(name="run")
public class RunCommand implements Callable<Integer> {
  @Spec CommandSpec spec;

  public final Integer call() {
    return new YamlRunner(yamlFile, getRootCommandLine()).run();
  }

  private final CommandLine getRootCommandLine() {
    var cl = commandHelper.getCommandSpec().commandLine();
    while ( true ) {
      if ( cl.getParent()==null ) break;
        cl = cl.getParent();
    }
    return cl;
  }
} 

@RequiredArgsContructor
public class YamlRunner {
  private final String yamlFile;
  private final CommandLine rootCL;
  public int run() {
    ...
    return someExitCode;
  }
  private void handleCmd(cmdElt) {
    int exitCode = rootCL.execute(cmdElt.getArgs());
    // handle exitCode
  }
}

Ideally, I'd also like to have a generic mechanism to allow the sub-commands being run to pass data back to the YamlRunner through Java method calls. Is there any way to pass some Java object to the command being executed, for example using some execution context that can be retrieved through the CommandSpec (not sure whether something like this exists in picocli), or by calling an interface method on the command to be executed before and after execution?

[remkop]

If you want to pass Java objects via the memory of the Java runtime, you could set some static value and let each command read that static value for further processing. (The Java equivalent of a global variable.)

An alternative is to serialize the object to a file and pass the path to that file as a command line argument.

That's all I can think of now.

[rsenden]

Thanks, I'm currently indeed using static methods/variables, I was just wondering whether there was any 'cleaner' approach, providing some kind of context that exists only during command execution.

Slightly cleaner might be to inject some value into the command being invoked, i.e., check whether the command to be invoked implements a certain interface, and if so, inject a value. Although I'm not injecting any value (yet), I do now use this approach to check what kind of command we're running, using code like the following:

    public final CommandLine getRootCommandLine(CommandSpec spec) {
        var cl = spec.commandLine();
        while ( true ) {
            if ( cl.getParent()==null ) break;
            cl = cl.getParent();
        }
        return cl;
    }

    public final CommandSpec getLeafCommandSpec(ParseResult parseResult) {
        var leafCommand = parseResult.subcommand();
        while (leafCommand.hasSubcommand() ) {
            leafCommand = leafCommand.subcommand();
        }
        return leafCommand.commandSpec();
    }

    public final int execute(CommandLine rootCommandLine, ParseResult parseResult) {
        try {
            rootCommandLine.clearExecutionResults();
            return rootCommandLine.getExecutionStrategy().execute(parseResult);
        } catch ( Exception e ) {
            throw new SomeException("Command threw an exception", e);
        }
    }

// spec parameter comes from @Spec annotated field
// args comes from yaml file or some other source
var rootCommandLine = getRootCommandLine(spec)
var parseResult = rootCommandLine.parseArgs(args);
var leafCommandSpec = getLeafCommandSpec(parseResult);
var leafCommand = leafCommandSpec.userObject();
if ( leafCommand instanceof SomeInterface ( {
  // Do something, for example inject some object into leafCommand
}
var exitCode = execute(rootCommandLine, parseResult);
// Potential clean up, like removing/resetting objects injected into leafCommand
// Do something with exitCode

Of course, there's a lot more to it in the actual application, like intercepting stdout/stderr of the command being invoked, but the above is more or less all picocli-related code that I'm using to dynamically invoke commands from another command.

Would this be the correct approach, or do you see any potential issues? Note that in this context, I'm not interested in generating help information if for example command options are incorrect.