maven/maven-argeo-qooxdoo-plugin/src/main/java/org/argeo/slc/maven/plugins/qooxdoo/GenerateMojo.java

   1 package org.argeo.slc.maven.plugins.qooxdoo;
   2
   3 import java.io.File;
   4
   5 import org.apache.maven.plugin.AbstractMojo;
   6 import org.apache.maven.plugin.MojoExecutionException;
   7 import org.apache.maven.plugin.MojoFailureException;
   8 import org.apache.maven.plugin.logging.Log;
   9 import org.codehaus.plexus.util.cli.CommandLineException;
  10 import org.codehaus.plexus.util.cli.CommandLineUtils;
  11 import org.codehaus.plexus.util.cli.Commandline;
  12 import org.codehaus.plexus.util.cli.StreamConsumer;
  13
  14 /**
  15  * Calls Qooxdoo python tool chain
  16  *
  17  * @goal generate
  18  * @execute goal="env"
  19  */
  20 public class GenerateMojo extends AbstractMojo {
  21         /**
  22          * The Qooxdoo build target.
  23          *
  24          * @parameter expression="${job}"
  25          * @required
  26          */
  27         private String job;
  28
  29         /**
  30          * The build directory.
  31          *
  32          * @parameter expression="${project.build.directory}"
  33          * @required
  34          */
  35         private File buildDirectory;
  36
  37         /**
  38          * The directory for the pom
  39          *
  40          * @parameter expression="${basedir}"
  41          * @required
  42          */
  43         private File baseDir;
  44
  45         public void execute() throws MojoExecutionException, MojoFailureException {
  46                 try {
  47                         // File jythonBase = new File(buildDirectory, "jython");
  48                         // jythonBase.mkdirs();
  49                         // System.setProperty("python.home", jythonBase.getCanonicalPath());
  50
  51                         File generateScript = new File(baseDir, "generate.py");
  52                         // String[] jobArray = jobs.split(" ");
  53                         // String[] args = new String[jobArray.length + 1];
  54                         // args[0] = generateScript.getCanonicalPath();
  55                         // System.arraycopy(jobArray, 0, args, 1, jobArray.length);
  56                         String[] args = { "generate.py", job };
  57                         getLog().info("Running Qooxdoo job: " + job + " ...");
  58                         // jython.main(args);
  59
  60                         Commandline cl = new Commandline();
  61                         cl.setExecutable("python");
  62                         cl.setWorkingDirectory(baseDir.getCanonicalPath());
  63                         cl.createArgument().setValue(generateScript.getCanonicalPath());
  64                         cl.createArgument().setValue(job);
  65
  66                         StreamConsumer stdout = new StdoutConsumer(getLog());
  67                         StreamConsumer stderr = new StderrConsumer(getLog());
  68                         try {
  69                                 int result = CommandLineUtils.executeCommandLine(cl, stdout,
  70                                                 stderr);
  71                                 if (result != 0) {
  72                                         throw new MojoExecutionException("Qooxdoo job returned: \'"
  73                                                         + result + "\'.");
  74                                 }
  75                         } catch (CommandLineException e) {
  76                                 throw new MojoExecutionException("Unable to run Qooxdoo job", e);
  77                         }
  78                         getLog().info("Finished Qooxdoo job: " + job);
  79
  80                 } catch (Exception e) {
  81                         throw new MojoExecutionException(
  82                                         "Unexpected exception when running Jython", e);
  83                 }
  84
  85         }
  86
  87         /**
  88          * Consumer to receive lines sent to stdout. The lines are logged as info.
  89          */
  90         private class StdoutConsumer implements StreamConsumer {
  91                 /** Logger to receive the lines. */
  92                 private Log logger;
  93
  94                 /**
  95                  * Constructor.
  96                  *
  97                  * @param log
  98                  *            The logger to receive the lines
  99                  */
 100                 public StdoutConsumer(Log log) {
 101                         logger = log;
 102                 }
 103
 104                 /**
 105                  * Consume a line.
 106                  *
 107                  * @param string
 108                  *            The line to consume
 109                  */
 110                 public void consumeLine(String string) {
 111                         logger.info(string);
 112                 }
 113         }
 114
 115         /**
 116          * Consumer to receive lines sent to stderr. The lines are logged as
 117          * warnings.
 118          */
 119         private class StderrConsumer implements StreamConsumer {
 120                 /** Logger to receive the lines. */
 121                 private Log logger;
 122
 123                 /**
 124                  * Constructor.
 125                  *
 126                  * @param log
 127                  *            The logger to receive the lines
 128                  */
 129                 public StderrConsumer(Log log) {
 130                         logger = log;
 131                 }
 132
 133                 /**
 134                  * Consume a line.
 135                  *
 136                  * @param string
 137                  *            The line to consume
 138                  */
 139                 public void consumeLine(String string) {
 140                         logger.warn(string);
 141                 }
 142         }
 143
 144 }