AbstractDotNetMojo.java

/*
 * Maven and Sonar plugin for .Net
 * Copyright (C) 2010 Jose Chillan and Alexandre Victoor
 * mailto: jose.chillan@codehaus.org or alexvictoor@codehaus.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
 */

package org.apache.maven.dotnet;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.maven.dotnet.commons.project.DotNetProjectException;
import org.apache.maven.dotnet.commons.project.VisualStudioProject;
import org.apache.maven.dotnet.commons.project.VisualStudioSolution;
import org.apache.maven.dotnet.commons.project.VisualStudioUtils;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import org.codehaus.plexus.util.cli.StreamConsumer;

/**
 * A utilitary class to factor some features for the DotNet relative mojos.
 * 
 * @author Jose CHILLAN Apr 14, 2009
 */
public abstract class AbstractDotNetMojo extends AbstractMojo {
  /**
   * Name of the file that contains the names of the files to export in a
   * resource folder
   */
  private final static String CONTENT_FILE_NAME = "content.txt";

  /**
   * A utility empty array.
   */
  private static final String[] EMPTY_STRING_ARRAY = new String[0];

  /**
   * The name of the solution to use in case there are multiple solutions in the
   * folder AND none has the same name as the artifact with a ".sln" extension.
   * 
   * @parameter expression="${visual.studio.solution}"
   */
  protected String solutionName;

  /**
   * The name of the project to use if it doesn't have the same name as the
   * artifact with a ".csproj" extension.
   * 
   * @parameter expression="${visual.studio.project}"
   */
  protected String projectName;

  /**
   * A pattern that will help to figure out if a project is a test project from
   * its name. The '*' and '?' common jokers are accepted. Several patterns may be 
   * specified using ";" as a delimiter.
   * 
   * @parameter expression="${visual.test.project.pattern}"
   *            default-value="*.Tests"
   */
  protected String testProjectPattern;

  /**
   * The build configurations to use for the project or solution, separated by
   * colons or semi-colons as in "Debug,Release".
   * Default value is "Debug". If value is "ALL", all the build configurations defined
   * in the sln file will be used.
   * 
   * @parameter expression="${msbuild.configurations}"
   *            alias="${buildConfigurations}" default-value="Debug"
   */
  protected String buildConfigurations;
  
  /**
   * Defines if the build should generate debug symbols (typically .pdb files)
   * 
   * @parameter expression="${maven.compiler.debug}" default-value="true"
   */
  protected boolean generatePdb;

  /**
   * Defines if the plugin can use the maven-dotnet-runtime artifact to export
   * the relevant .Net quality applications instead of using their global path.
   * The defined path is always taken in priority.
   * 
   * @parameter expression="${dotnet.use.embedded.runtime}" default-value="true"
   */
  protected boolean useEmbbededRuntime;

  /**
   * Location of the output files
   * 
   * @parameter expression="${project.build.directory}"
   * @required
   */
  protected File outputDirectory;

  /**
   * The maven project.
   * 
   * @parameter expression="${project}"
   * @required
   */
  protected MavenProject project;

  /**
   * Defines if the launched commands should be appended into a "command.txt"
   * file. For debug purpose.
   * 
   * @parameter expression="${trace.commands}"
   */
  protected boolean traceCommands = false;
  
  /**
   * List of the excluded projects, using ',' as delimiter. C# files
   * of these projects will be ignored. No violation on files
   * of these projects should be reported. 
   * 
   * @parameter expression="${skippedProjects}"
   */
  protected String skippedProjects;

  /**
   * Locations of the assemblies that should be analysed in case default location
   * should not be used. Actually AOP tools such as PostSharp mess up the cil and 
   * may provoke false positives. 
   * Project names should be used as keys. Values should be the path to the wanted DLLs. 
   * If the assembly of the "Cache" project is located in the "compile" directory instead 
   * of usual "bin/Debug", you can add in the configuration section of the plugin something 
   * like <assemblyDirectories\><Cache>compile</Cache></assemblyDirectories> 
   * @parameter
   */
  protected Map<String, String> assemblyDirectories = new HashMap<String, String>();
  

  /**
   * Constructs a @link{AbstractDotNetMojo}.
   */
  public AbstractDotNetMojo() {
  }

  
  /**
   * Launches the MOJO action. <br/>
   * This method checks whether the pom.xml is for a project or a solution and
   * launches the adequate method {@link #executeProject(VisualStudioProject)}
   * or {@link #executeSolution(VisualStudioSolution)}.
   * 
   * @throws MojoExecutionException
   * @throws MojoFailureException
   */
  @Override
  public void execute() throws MojoExecutionException, MojoFailureException {
    if (!checkExecutionAllowed()) {
      return;
    }

    // Here we should add : if the project is a "sln" packaging, then launch for
    // the solution
    if (VisualStudioUtils.SOLUTION_PACKAGINGS.contains(project.getPackaging())) {
      VisualStudioSolution visualSolution = null;
      try {
        visualSolution = VisualStudioUtils.getVisualSolution(project,
            solutionName);
      } catch (DotNetProjectException e) {
        throw new MojoExecutionException(
            "The solution for project "
                + project.getArtifactId()
                + " is not a "
                + "properly configured Visual Studio solution.\nPlease ensure you have a '.sln' file in "
                + project.getBasedir(), e);

      }
      if (visualSolution == null) {
        throw new MojoExecutionException(
            "The solution for project "
                + project.getArtifactId()
                + " is not a "
                + "properly configured Visual Studio solution.\nPlease ensure you have a '.sln' file in "
                + project.getBasedir());
      }
      
      if ("ALL".equals(buildConfigurations)) {
        buildConfigurations = StringUtils.join(visualSolution.getBuildConfigurations(),',');
      }
      
      if (assemblyDirectories != null ) {
        visualSolution.overrideAssemblyDirectories(assemblyDirectories);
      }
      
      visualSolution.filterProjects(skippedProjects);
      
      executeSolution(visualSolution);
      return;
    }

    VisualStudioProject visualProject = getVisualProject();
    if (visualProject == null) {
      getLog().info(
          "The project " + project.getArtifactId()
              + " is not a visual studio project");
      return;
    }
    executeProject(visualProject);
  }

  /**
   * Launches the action in case the project is a VisualStudio project
   * 
   * @param visualProject
   */
  protected abstract void executeProject(VisualStudioProject visualProject)
      throws MojoExecutionException, MojoFailureException;

  /**
   * Launches the action in case the project is a VisualStudio solution
   * 
   * @param visualSolution
   */
  protected abstract void executeSolution(VisualStudioSolution visualSolution)
      throws MojoExecutionException, MojoFailureException;

  /**
   * Gets the Visual Studio project associated to the current project.
   * 
   * @return the project, or <code>null</code> if the project is not a Visual
   *         Studio project
   * @throws MojoExecutionException
   *           if the current pom.xml correspond to a badly defined project
   */
  protected final VisualStudioProject getVisualProject()
      throws MojoExecutionException {
    File projectFile;
    try {
      projectFile = VisualStudioUtils.getVisualFile(project, projectName,
          ".csproj", "project");
    } catch (DotNetProjectException except) {
      throw new MojoExecutionException(
          "Could not create a VisualStudio project", except);
    }
    // No solution defined
    if (projectFile == null) {
      getLog().debug(
          "The project " + project.getName()
              + " is not a Visual Studio project");
      return null;
    }
    try {
      VisualStudioProject visualProject = VisualStudioUtils
          .getProject(projectFile);
      assessTestProject(visualProject);
      return visualProject;
    } catch (FileNotFoundException e) {
      throw new MojoExecutionException(
          "Could not extract the project information for " + projectFile, e);
    } catch (DotNetProjectException e) {
      throw new MojoExecutionException(
          "Could not extract the project information for " + projectFile, e);
    }
  }

  /**
   * Gets the solution corresponding to the current project if applicable.
   * 
   * @return the generated solution, or <code>null</code> if the project is not
   *         a solution
   */
  protected final VisualStudioSolution getVisualSolution()
      throws MojoExecutionException {
    File basedir = project.getBasedir();
    File solutionFile;
    try {
      solutionFile = VisualStudioUtils.getVisualFile(project, solutionName,
          ".sln", "solution");
    } catch (DotNetProjectException except) {
      throw new MojoExecutionException(
          "Could not create a VisualStudio solution", except);
    }

    // No solution defined
    if (solutionFile == null) {
      getLog().debug(
          "The project " + project.getName()
              + " is not a Visual Studio solution");
      return null;
    }
    // We define the solution file
    solutionName = solutionFile.getName();
    // We try to build the solution
    VisualStudioSolution solution;
    try {
      solution = VisualStudioUtils.getSolution(basedir, solutionName);
    } catch (Exception e) {
      throw new MojoExecutionException(
          "Could not extract the solution information for " + solutionFile, e);
    }
    List<VisualStudioProject> projects = solution.getProjects();
    // We define for each project if it is a test project
    for (VisualStudioProject visualStudioProject : projects) {
      assessTestProject(visualStudioProject);
    }
    return solution;
  }

  /**
   * @param visualStudioProject
   */
  private void assessTestProject(VisualStudioProject visualStudioProject) {
    VisualStudioUtils.assessTestProject(visualStudioProject, testProjectPattern);
  }

  /**
   * Deletes a set of file before generation
   * 
   * @param files
   *          the files to delete
   */
  protected void deleteFiles(File... files) {
    for (File file : files) {
      if (file.exists()) {
        file.delete();
      }
    }
  }

  /**
   * Ensures that the current running system is a Windows version
   * 
   * @throws MojoExecutionException
   *           if the system is not windows
   */
  protected void ensureWindowsSystem() throws MojoExecutionException {
    String osName = System.getProperty("os.name").toLowerCase();
    if (!osName.contains("windows")) {
      throw new MojoExecutionException(
          "The task must be launched on a Windows system");
    }
  }

  /**
   * Ensure that the java version is at least 1.6
   * 
   * @throws MojoExecutionException
   */
  protected void ensureJavaVersion() throws MojoExecutionException {
    String version = System.getProperty("java.version");
    int versionValue = Integer.parseInt(new StringBuilder()
        .append(version.charAt(0)).append(version.charAt(2)).toString());
    if (versionValue < 16) {
      throw new MojoExecutionException(
          "The C# reporting plugin requires to be run in at least the JDK 6.0");
    }
  }

  /**
   * Launches a command line, redirecting the stream to the maven logs.
   * @param reportType
   *          a display type for the report
   * @param acceptedMask
   *          a mask for the exit code of the command that is accepted (put 0 if
   *          you don't know)
   * @param commandline
   *          the command ready to be executed
   * 
   * @return the status of the command after execution
   * @throws MojoExecutionException
   *           if the execution command could not be launched for any reason
   * @throws MojoFailureException
   *           if the command status after execution is not satisfying
   */
  protected int launchCommand(File executable, List<String> arguments,
      String reportType, int acceptedMask)
    throws MojoExecutionException, MojoFailureException {
    Commandline commandline = generateCommandLine(executable, arguments);
    return launchCommand(commandline, reportType, acceptedMask,
        true);
  }

  /**
   * Launches a command line, redirecting the stream to the maven logs
   * @param commandline
   *          the command ready to be executed
   * @param reportType
   *          a display type for the report
   * @param acceptedMask
   *          a mask for the exit code of the command that is accepted (put 0 if
   *          you don't know)
   * @param throwsFailure
   *          <code>true</code> if the method should throw an exception in case
   *          of failure
   * 
   * @return the status of the command after execution
   * @throws MojoExecutionException
   *           if the execution command could not be launched for any reason
   * @throws MojoFailureException
   *           if the command status after execution is not satisfying and the
   *           throwsFailure parameter is not false
   */
  protected int launchCommand(Commandline commandline, String reportType,
      int acceptedMask, boolean throwsFailure)
    throws MojoExecutionException, MojoFailureException {
    int commandLineResult;
    Log log = getLog();
    String[] commandLineElements = commandline.getCommandline();

    CommandStreamConsumer systemOut = new CommandStreamConsumer(log);

    try {
      // Execute the commandline
      log.debug("Executing command: " + commandline);
      log.debug("Command elements :" + Arrays.toString(commandLineElements));
      ProcessBuilder builder = new ProcessBuilder(
          Arrays.asList(commandLineElements));
      builder.redirectErrorStream(true);
      if (traceCommands) {
        try {
          File commandFile = getReportFile("command.txt");
          OutputStream stream = new FileOutputStream(commandFile, true);
          PrintWriter writer = new PrintWriter(stream);
          writer.println("Mojo : " + reportType + " on "
              + new Timestamp(System.currentTimeMillis()));
          writer.println(commandline);
          writer.println();
          writer.close();
        } catch (FileNotFoundException e) {
          // Nothing : commands are not logged
          log.debug("command.txt not found");
        }
      }
      commandLineResult = CommandLineUtils.executeCommandLine(commandline,
          systemOut, systemOut);

      // Check if nunit-console is not in the path
      if (systemOut.isCommandNotFound()) {
        throw new MojoExecutionException("Please add the executable for "
            + reportType + " to your path");
      } else if ((commandLineResult & (~acceptedMask)) != 0) {
        
        if (log.isWarnEnabled()) {
          log.warn("FAILURE !!!");
          log.warn("Launched command : " + commandline);
          log.warn("");
          log.warn(systemOut.getContent());
        }
        // We throw the exception only if asked for
        if (throwsFailure) {
          throw new MojoFailureException("Failure during the " + reportType
              + " generation that ended with status=" + commandLineResult);
        }
      }
    } catch (CommandLineException e) {
      throw new MojoExecutionException("Failure during the " + reportType
          + " generation, executing commandline:\n" + commandline, e);
    }
    return commandLineResult;
  }

  /**
   * Generates a command line with the arguments.
   * 
   * @param executable
   * @param arguments
   * @return
   */
  protected Commandline generateCommandLine(File executable,
      List<String> arguments) {
    Commandline commandline = new Java5CommandLine();

    // We create the work directory if necessary
    if (!outputDirectory.exists()) {
      outputDirectory.mkdirs();
    }

    commandline.setWorkingDirectory(outputDirectory.toString());
    commandline.setExecutable(executable.toString());
    commandline.addArguments(arguments.toArray(EMPTY_STRING_ARRAY));
    return commandline;
  }

  /**
   * Exports a resource folder to a subdirectory of the maven build directory. <br/>
   * The folder is supposed to contain a "context.txt" file that contains the
   * list of the files to export, one name per line
   * 
   * @param resourceDir
   *          the resource directory to export
   * @param destinationSubFolder
   *          the subfolder to use, that will be created under
   *          ${project.build.dir}
   * @param application
   *          the exported application
   * @return the generated folder
   * @throws MojoExecutionException
   */
  protected File extractFolder(String resourceDir, String destinationSubFolder,
      String application) throws MojoExecutionException {
    if (!useEmbbededRuntime) {
      getLog()
          .warn(
              "The use of the embedded runtime package is not enabled. Please add the settings 'dotnet.use.embedded.runtime=true'");
      throw new MojoExecutionException(
          "The use of the embedded runtime package is not enabled for "
              + application);
    }
    getLog().debug("Exporting files for " + application);
    String contentFile = resourceDir + "/" + CONTENT_FILE_NAME;
    
    InputStream contentResource = getClassLoader().getResourceAsStream(
        contentFile);
    
    if (contentResource==null) {
      throw new MojoExecutionException(application + " binaries were not found");
    }
    
    LineNumberReader reader = new LineNumberReader(new InputStreamReader(
        contentResource));
    String line = null;
    List<String> contentFiles = new ArrayList<String>();
    try {
      while ((line = reader.readLine()) != null) {
        contentFiles.add(line.trim());
      }
    } catch (IOException e) {
      throw new MojoExecutionException("Could not extract the files for "
          + application, e);
    }
    File reportDirectory = getReportDirectory();
    File extractFolder = new File(reportDirectory, destinationSubFolder);
    extractResources(extractFolder, resourceDir, contentFiles, application);
    return extractFolder;
  }

  /**
   * Extracts the resources to a specified directory.
   * 
   * @param destinationDirectory
   *          the directory to which the files will be extracted
   * @param resourceDirectory
   *          the resource directory from which they are extracted
   * @param resourceNames
   *          the name of the resource files to extract
   * @param application
   *          the name of the application for debug purpose
   * @throws MojoExecutionException
   *           if a file is missing or the folder could not be written to
   */
  protected void extractResources(File destinationDirectory,
      String resourceDirectory, List<String> resourceNames, String application)
    throws MojoExecutionException {
    if (!destinationDirectory.exists()) {
      destinationDirectory.mkdirs();
    }
    for (String resource : resourceNames) {
      extractResource(destinationDirectory, resourceDirectory + "/" + resource,
          resource, application);
    }
  }

  /**
   * Extracts a resource file from the plugin jar to a given destination folder.
   * 
   * @param exportDirectory
   *          the destination folder
   * @param resourcePath
   *          the full path to the extracted resource
   * @param fileName
   *          the name of the file after export (usually the terminal part of
   *          resourcePath)
   * @param application
   *          the name of the application for debug purpose
   * @return the exported file
   * @throws MojoExecutionException
   *           if the resource is not found or the file could no be written
   */
  protected File extractResource(File exportDirectory, String resourcePath,
      String fileName, String application) throws MojoExecutionException {
    File exportedFile = new File(exportDirectory, fileName);

    // First we create the parent folder if necessary
    // NOTE here that as the resource may be far in the subtree,
    // the parent is not necessary the export directory
    File parentDirectory = exportedFile.getParentFile();
    if (!parentDirectory.exists()) {
      getLog().debug("Creating parent export directory : " + parentDirectory);
      parentDirectory.mkdirs();
    }

    // We delete the file to replace it
    if (exportedFile.exists()) {
      exportedFile.delete();
    }
    // Exports the file
    try {
      exportedFile.createNewFile();
      InputStream fileStream = getClassLoader().getResourceAsStream(
          resourcePath);
      OutputStream out = new FileOutputStream(exportedFile);
      long length = 0;
      byte buf[] = new byte[1024];
      int len;
      // We write all the bytes by block
      while ((len = fileStream.read(buf)) > 0) {
        out.write(buf, 0, len);
        length += len;
      }
      out.close();
      fileStream.close();
      getLog().debug(
          "Exported file " + exportedFile + " : " + length + " bytes");
    } catch (Exception e) {
      // Something went wrong...
      throw new MojoExecutionException("A problem occurred for " + application
          + " while extracting file " + fileName + " to " + exportedFile, e);
    }
    return exportedFile;
  }

  /**
   * Gets a file for a report whose name is given
   * 
   * @param fileName
   *          the name of the file
   * @return the file to generate
   */
  protected File getReportFile(String fileName) {
    File reportDirectory = getReportDirectory();
    return new File(reportDirectory, fileName);
  }

  /**
   * Escapes a file if necessary for command generation.
   * 
   * @param file
   *          the file to escape
   * @return the escapes file name
   * 
   */
  protected String toCommandPath(File file) {
    String absolutePath;
    try {
      absolutePath = file.getCanonicalPath();
    } catch (IOException e) {
      // We try another way of processing
      absolutePath = file.getAbsolutePath();
    }
    return absolutePath;
  }

  /**
   * Gets the current class loader
   * 
   * @return
   */
  protected ClassLoader getClassLoader() {
    return Thread.currentThread().getContextClassLoader();
  }

  /**
   * Gets the report directory to use.
   * 
   * @return the report directory
   */
  protected File getReportDirectory() {
    String buildPath = project.getBuild().getDirectory();
    File reportDirectory = new File(buildPath);
    reportDirectory.mkdirs(); 
    return reportDirectory;
  }

  /**
   * Ensures that the execution of the Mojo is allowed. <br/>
   * The current implementation checks that the execution is launched on a
   * Windows system and uses at least Java 6.0. This method may be overridden
   * but should better invoke the super.
   * 
   * @return <code>true</code> if the execution is allowed
   * @throws MojoExecutionException
   */
  protected boolean checkExecutionAllowed() throws MojoExecutionException {
    ensureWindowsSystem();
    ensureJavaVersion();
    return true;
  }
  
  /**
   * A consumer for command outputs.
   * 
   * @author Jose CHILLAN Jul 30, 2009
   */
  private static final class CommandStreamConsumer implements StreamConsumer {
    
    private static final String COMMAND_NOT_FOUND_FRAGMENT = "is not recognized as an internal or external command";

    private boolean commandNotFound;
    private StringBuilder consumedLines = new StringBuilder();

    private Log log;

    private CommandStreamConsumer(Log log) {
      this.log = log;
    }

    /**
     * Callback each time a line is consumed.
     * 
     * @param line
     */
    @Override
    public void consumeLine(String line) {
      consumedLines.append(line + "\n");

      log.info(line);
     
      if (line.contains(COMMAND_NOT_FOUND_FRAGMENT)) {
        commandNotFound = true;
      }
    }

    /**
     * Checks if the command was not found.
     * 
     * @return <code>true</code> if the command was not found
     */
    public boolean isCommandNotFound() {
      return commandNotFound;
    }

    /**
     * Gets the content of the stream.
     * 
     * @return the stream content
     */
    public CharSequence getContent() {
      return consumedLines;
    }
  }
}