ForkedMacker.java

package org.codehaus.mojo.macker;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.plugin.logging.SystemStreamLog;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

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.CommandLineUtils.StringStreamConsumer;

/**
 * Forking to invoke the Macker tool.  Based on
 * <code>org.codehaus.mojo.cobertura.tasks.AbstractTask</code>.
 * This uses the Shell from CommandLine for forking. In Windows XP this has
 * a max of 8kb command line arguments.  So we have to use a command file.
 * @author <a href="http://www.code-cop.org/">Peter Kofler</a>
 */
public class ForkedMacker
    implements Macker
{
    private static final String COMMAND_CLASS = CommandLineFile.class.getName();
    private static final String TASK_CLASS = "net.innig.macker.Macker";

    private List/*<String>*/options = new ArrayList/*<String>*/();
    private List/*<String>*/rules = new ArrayList/*<String>*/();
    private List/*<String>*/classes = new ArrayList/*<String>*/();
    private Log log = new SystemStreamLog();
    private String maxmem;
    private List/*<Artifact>*/pluginClasspathList = Collections.EMPTY_LIST;
    private boolean quiet;

    private String createClasspath()
        throws MojoExecutionException
    {
        StringBuffer cpBuffer = new StringBuffer();
        for ( Iterator it = pluginClasspathList.iterator(); it.hasNext(); )
        {
            Artifact artifact = (Artifact) it.next();
            try
            {
                cpBuffer.append( artifact.getFile().getCanonicalPath() );
                if ( it.hasNext() )
                {
                    cpBuffer.append( File.pathSeparator );
                }
            }
            catch ( IOException e )
            {
                throw new MojoExecutionException( "Error while creating the canonical path for '" + artifact.getFile()
                        + "'.", e );
            }
        }

        return cpBuffer.toString();
    }

    private Commandline createCommandLine()
        throws MojoExecutionException
    {
        // Commandline cl = new Commandline();
        // cl.setExecutable( "java" );
        // cl.createArg().setValue( "-cp" );
        // cl.createArg().setValue( createClasspath() );
        // if ( maxmem != null )
        // {
        //     cl.createArg().setValue( "-Xmx" + maxmem );
        // }
        // cl.createArg().setValue( commandClass );
        List/*<String>*/jvmArguments = new ArrayList/*<String>*/();
        jvmArguments.add( "-cp" );
        jvmArguments.add( createClasspath() );
        if ( maxmem != null )
        {
            jvmArguments.add( "-Xmx" + maxmem );
        }
        Commandline cl = new Commandline( new JavaShell( jvmArguments ) );
        cl.setExecutable( COMMAND_CLASS );

        cl.createArg().setValue( TASK_CLASS );
        try
        {
            CommandLineBuilder builder = new CommandLineBuilder( "macker" );
            for ( Iterator/*<String>*/it = options.iterator(); it.hasNext(); )
            {
                builder.addArg( (String) it.next() );
            }
            for ( Iterator/*<String>*/it = rules.iterator(); it.hasNext(); )
            {
                builder.addArg( (String) it.next() );
            }
            for ( Iterator/*<String>*/it = classes.iterator(); it.hasNext(); )
            {
                builder.addArg( (String) it.next() );
            }
            builder.saveArgs();
            String commandsFile =  builder.getCommandLineFile();
            cl.createArg().setValue( commandsFile );
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException( "Unable to create CommandsFile.", e );
        }
        return cl;
    }

    private int executeJava()
        throws MojoExecutionException
    {
        Commandline cl = createCommandLine();

        StringStreamConsumer stdout = new StringStreamConsumer();
        StringStreamConsumer stderr = new StringStreamConsumer();
        if ( quiet )
        {
            StringStreamConsumer nullConsumer = new StringStreamConsumer()
            {
                public void consumeLine( String s )
                {
                }
            };
            stdout = nullConsumer;
            stderr = nullConsumer;
        }
        log.debug( "Working Directory: " + cl.getWorkingDirectory() );
        log.debug( "Executing command line:" );
        log.debug( cl.toString() );

        int exitCode;
        try
        {
            exitCode = CommandLineUtils.executeCommandLine( cl, stdout, stderr );
        }
        catch ( CommandLineException e )
        {
            throw new MojoExecutionException( "Unable to execute Macker.", e );
        }
        log.debug( "exit code: " + exitCode );

        String output = stdout.getOutput();
        if ( output.trim().length() > 0 )
        {
            log.debug( "--------------------" );
            log.debug( " Standard output from the Macker task:" );
            log.debug( "--------------------" );
            log.info( output );
            log.debug( "--------------------" );
        }
        String stream = stderr.getOutput();
        if ( stream.trim().length() > 0 )
        {
            log.debug( "--------------------" );
            log.debug( " Standard error from the Macker task:" );
            log.debug( "--------------------" );
            log.error( stderr.getOutput() );
            log.debug( "--------------------" );
        }
        return exitCode;
    }

    public void check()
        throws MojoExecutionException, MojoFailureException
    {
        int returnCode = executeJava();
        switch ( returnCode )
        {
        case 0:
            log.debug( "All checks passed." );
            break;
        case 2:
            log.debug( "Macker check failed." );
            throw new MojoFailureException( "MackerIsMadException during Macker execution" );
        default:
            log.error( "Macker check had errors. See messages above." );
            throw new MojoExecutionException( "Error during Macker execution" );
        }
    }

    public void setLog( Log log )
    {
        this.log = log;
    }

    public void setMaxmem( String maxmem )
    {
        this.maxmem = maxmem;
    }

    public void setPluginClasspathList( List/*<Artifact>*/pluginClasspathList )
    {
        this.pluginClasspathList = Collections.unmodifiableList( pluginClasspathList );
    }

    public void setQuiet( boolean quiet )
    {
        this.quiet = quiet;
    }

    public void addClass( File clazz )
        throws IOException
    {
        classes.add( clazz.getCanonicalPath() );
    }

    public void addRulesFile( File rule )
        throws IOException
    {
        // -r, --rulesfile <rules.xml>
        rules.add( "-r" );
        rules.add( rule.getCanonicalPath() );
    }

    public void setAngerThreshold( String anger )
    {
        // --anger <threshold>
        options.add( "--anger" );
        options.add( anger );
    }

    public void setPrintMaxMessages( int maxMsg )
    {
        // --print-max <max-messages>
        options.add( "--print-max" );
        options.add( "" + maxMsg );
    }

    public void setPrintThreshold( String print )
    {
        // --print <threshold>
        options.add( "--print" );
        options.add( print );
    }

    public void setVariable( String name, String value )
    {
        // -D, --define <var>=<value>
        options.add( "-D" );
        options.add( name + "=" + value );
    }

    public void setVerbose( boolean verbose )
    {
        if ( verbose )
        {
            // -v, --verbose
            options.add( "-v" );
        }
    }

    public void setXmlReportFile( File report )
        throws IOException
    {
        // -o, --output <report.xml>
        options.add( "-o" );
        options.add( report.getCanonicalPath() );
    }
}