Question

I am working on a (Codehaus) Maven 2 Mojo. Unfortunately the logic called has a not compatible license and I have to fork a separate process (as it is done for Cobertura maven plugin).

Forking itself is easy using org.codehaus.plexus.util.cli.Commandline and friends. The fork needs to be able to set thousands of arguments to the main method of the called process (which is the third party code to be used). On Windows, Commandline can only be 8k long. Using direct fork (Runtime.getRuntime().exec) supports only up to 32k total argument size, which is still not enough.

So I need a wrapper around the 3rd party tool, which reads lines from a text file (the command file) and calls the target class with them. It’s easy to code that and I could do it myself but then I have another one of my classes calling the 3rd party code, which can’t be in the Mojo’s code base itself because of license problems (as above). Best would be a library that I can pull in as dependency that does that for me.

Do you know such a library/class I could use (without setting up another project, which needs to be released bla bla bla).

Answer 1

Obviously (as no one answered) there is no such a thing to use out of the box. So I had to come up with one myself.

• To create the commandline file I copied net.sourceforge.cobertura.util.CommandLineBuilder (source) which has addArg(), saveArgs() and getCommandLineFile() methods.

• To execute the commandline with that file I used org.codehaus.plexus.util.cli.Commandline as commonly used in MOJOs.

  Commandline cl = new Commandline();
  cl.setExecutable( COMMAND_CLASS );
  cl.createArg().setValue( TASK_CLASS );
  
  CommandLineBuilder builder = new CommandLineBuilder( "macker" );
  for ( Iterator/*<String>*/it = options.iterator(); it.hasNext(); ) {
     builder.addArg( (String) it.next() );
  }
  builder.saveArgs();
  String commandsFile =  builder.getCommandLineFile();
  cl.createArg().setValue( commandsFile );
  
  StringStreamConsumer stdout = new StringStreamConsumer();
  StringStreamConsumer stderr = new StringStreamConsumer();
  int exitCode = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
  

• The “other” side has to unpack the arguments. I wrote a small class CommandLineFile (source) for that.

  String className = args[0];
  Class clazz = Class.forName( className );
  Method main = clazz.getMethod( "main", new Class[] { String[].class } );
  
  List/*<String>*/lines = new ArrayList/*<String>*/();
  Reader in = new InputStreamReader( new FileInputStream( args[1] ), "UTF-8" );
  try {
      lines = IOUtils.readLines( in );
  } finally {
      in.close();
  }
  
  main.invoke( null, new Object[] { lines.toArray( new String[lines.size()] ) } );
  

• The only problem that remained is the need for CommandLineFile to be on the classpath. But that is another story…

All used classes are generic and open source. So they could be used for any forking problem.