InvokerProperties.java

package org.apache.maven.plugins.invoker;

/*
 * 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 java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;
import java.util.function.Consumer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.maven.shared.invoker.InvocationRequest;
import org.codehaus.plexus.util.StringUtils;

/**
 * Provides a convenient facade around the <code>invoker.properties</code>.
 *
 * @author Benjamin Bentmann
 */
class InvokerProperties
{
    private static final String SELECTOR_PREFIX = "selector.";

    private static final Pattern ENVIRONMENT_VARIABLES_PATTERN =
            Pattern.compile( "invoker\\.environmentVariables\\.([A-Za-z][^.]+)(\\.([0-9]+))?" );

    // default values from Mojo configuration
    private Boolean defaultDebug;
    private Boolean defaultQuiet;
    private List<String> defaultGoals;
    private List<String> defaultProfiles;
    private String defaultMavenOpts;
    private Integer defaultTimeoutInSeconds;
    private Map<String, String> defaultEnvironmentVariables;
    private File defaultMavenExecutable;

    private enum InvocationProperty
    {
        PROJECT( "invoker.project" ),
        BUILD_RESULT( "invoker.buildResult" ),
        GOALS( "invoker.goals" ),
        PROFILES( "invoker.profiles" ),
        MAVEN_EXECUTABLE( "invoker.mavenExecutable" ),
        MAVEN_OPTS( "invoker.mavenOpts" ),
        FAILURE_BEHAVIOR( "invoker.failureBehavior" ),
        NON_RECURSIVE( "invoker.nonRecursive" ),
        OFFLINE( "invoker.offline" ),
        SYSTEM_PROPERTIES_FILE( "invoker.systemPropertiesFile" ),
        DEBUG( "invoker.debug" ),
        QUIET( "invoker.quiet" ),
        SETTINGS_FILE( "invoker.settingsFile" ),
        TIMEOUT_IN_SECONDS( "invoker.timeoutInSeconds" );

        private final String key;

        InvocationProperty( final String s )
        {
            this.key = s;
        }

        @Override
        public String toString()
        {
            return key;
        }
    }

    private enum SelectorProperty
    {
        JAVA_VERSION( ".java.version" ),
        MAVEN_VERSION( ".maven.version" ),
        OS_FAMLY( ".os.family" );

        private final String suffix;

        SelectorProperty( String suffix )
        {
            this.suffix = suffix;
        }

        @Override
        public String toString()
        {
            return suffix;
        }
    }

    /**
     * The invoker properties being wrapped.
     */
    private final Properties properties;

    /**
     * Creates a new facade for the specified invoker properties. The properties will not be copied, so any changes to
     * them will be reflected by the facade.
     *
     * @param properties The invoker properties to wrap, may be <code>null</code> if none.
     */
    InvokerProperties( Properties properties )
    {
        this.properties = ( properties != null ) ? properties : new Properties();
    }

    /**
     * Default value for debug
     * @param defaultDebug a default value
     */
    public void setDefaultDebug( boolean defaultDebug )
    {
        this.defaultDebug = defaultDebug;
    }

    /**
     * Default value for quiet
     * @param defaultQuiet a default value
     */
    public void setDefaultQuiet( boolean defaultQuiet )
    {
        this.defaultQuiet = defaultQuiet;
    }

    /**
     * Default value for goals
     * @param defaultGoals a default value
     */
    public void setDefaultGoals( List<String> defaultGoals )
    {
        this.defaultGoals = defaultGoals;
    }

    /**
     * Default value for profiles
     * @param defaultProfiles a default value
     */
    public void setDefaultProfiles( List<String> defaultProfiles )
    {
        this.defaultProfiles =  defaultProfiles;
    }

    /**
     * Default value for mavenExecutable
     * @param defaultMavenExecutable a default value
     */
    public void setDefaultMavenExecutable( File defaultMavenExecutable )
    {
        this.defaultMavenExecutable = defaultMavenExecutable;
    }

    /**
     * Default value for mavenOpts
     * @param defaultMavenOpts a default value
     */
    public void setDefaultMavenOpts( String defaultMavenOpts )
    {
        this.defaultMavenOpts = defaultMavenOpts;
    }

    /**
     * Default value for timeoutInSeconds
     * @param defaultTimeoutInSeconds a default value
     */
    public void setDefaultTimeoutInSeconds( int defaultTimeoutInSeconds )
    {
        this.defaultTimeoutInSeconds = defaultTimeoutInSeconds;
    }

    /**
     * Default value for environmentVariables
     * @param defaultEnvironmentVariables a default value
     */
    public void setDefaultEnvironmentVariables( Map<String, String> defaultEnvironmentVariables )
    {
        this.defaultEnvironmentVariables = defaultEnvironmentVariables;
    }

    /**
     * Gets the invoker properties being wrapped.
     *
     * @return The invoker properties being wrapped, never <code>null</code>.
     */
    public Properties getProperties()
    {
        return this.properties;
    }

    /**
     * Gets the name of the corresponding build job.
     *
     * @return The name of the build job or an empty string if not set.
     */
    public String getJobName()
    {
        return this.properties.getProperty( "invoker.name", "" );
    }

    /**
     * Gets the description of the corresponding build job.
     *
     * @return The description of the build job or an empty string if not set.
     */
    public String getJobDescription()
    {
        return this.properties.getProperty( "invoker.description", "" );
    }

    /**
     * Get the corresponding ordinal value
     *
     * @return The ordinal value
     */
    public int getOrdinal()
    {
        return Integer.parseInt( this.properties.getProperty( "invoker.ordinal", "0" ) );
    }

    /**
     * Gets the specification of JRE versions on which this build job should be run.
     *
     * @return The specification of JRE versions or an empty string if not set.
     */
    public String getJreVersion()
    {
        return this.properties.getProperty( "invoker.java.version", "" );
    }

    /**
     * Gets the specification of JRE versions on which this build job should be run.
     *
     * @return The specification of JRE versions or an empty string if not set.
     */
    public String getJreVersion( int index )
    {
        return this.properties.getProperty( SELECTOR_PREFIX + index + SelectorProperty.JAVA_VERSION,
                getJreVersion() );
    }

    /**
     * Gets the specification of Maven versions on which this build job should be run.
     *
     * @return The specification of Maven versions on which this build job should be run.
     * @since 1.5
     */
    public String getMavenVersion()
    {
        return this.properties.getProperty( "invoker.maven.version", "" );
    }

    /**
     * @param index the selector index
     * @return The specification of Maven versions on which this build job should be run.
     * @since 3.0.0
     */
    public String getMavenVersion( int index )
    {
        return this.properties.getProperty( SELECTOR_PREFIX + index + SelectorProperty.MAVEN_VERSION,
                getMavenVersion() );
    }

    /**
     * Gets the specification of OS families on which this build job should be run.
     *
     * @return The specification of OS families or an empty string if not set.
     */
    public String getOsFamily()
    {
        return this.properties.getProperty( "invoker.os.family", "" );
    }

    /**
     * Gets the specification of OS families on which this build job should be run.
     *
     * @param index the selector index
     * @return The specification of OS families or an empty string if not set.
     * @since 3.0.0
     */
    public String getOsFamily( int index )
    {
        return this.properties.getProperty( SELECTOR_PREFIX + index + SelectorProperty.OS_FAMLY, getOsFamily() );
    }

    public Collection<InvokerToolchain> getToolchains()
    {
        return getToolchains( Pattern.compile( "invoker\\.toolchain\\.([^.]+)\\.(.+)" ) );
    }

    public Collection<InvokerToolchain> getToolchains( int index )
    {
        return getToolchains( Pattern.compile( "selector\\." + index + "\\.invoker\\.toolchain\\.([^.]+)\\.(.+)" ) );
    }

    private Collection<InvokerToolchain> getToolchains( Pattern p )
    {
        Map<String, InvokerToolchain> toolchains = new HashMap<>();
        for ( Map.Entry<Object, Object> entry : this.properties.entrySet() )
        {
            Matcher m = p.matcher( entry.getKey().toString() );
            if ( m.matches() )
            {
                String type = m.group( 1 );
                String providesKey = m.group( 2 );
                String providesValue = entry.getValue().toString();

                InvokerToolchain tc = toolchains.get( type );
                if ( tc == null )
                {
                    tc = new InvokerToolchain( type );
                    toolchains.put( type, tc );
                }
                tc.addProvides( providesKey, providesValue );
            }
        }
        return toolchains.values();
    }

    /**
     * Extract environment variable from properties for given index.
     * Every environment variable without index is also returned.
     *
     * @param index index to lookup
     * @return map of environment name and value
     */

    private Map<String, String> getEnvironmentVariables( int index )
    {

        Map<String, String> envItems = new HashMap<>();

        for ( Map.Entry<Object, Object> entry : properties.entrySet() )
        {
            Matcher matcher = ENVIRONMENT_VARIABLES_PATTERN.matcher( entry.getKey().toString() );
            if ( matcher.matches() )
            {

                if ( String.valueOf( index ).equals( matcher.group( 3 ) ) )
                {
                    // variables with index has higher priority, so override
                    envItems.put( matcher.group( 1 ), entry.getValue().toString() );
                }
                else if ( matcher.group( 3 ) == null )
                {
                    // variables without index has lower priority, so check if exist
                    if ( !envItems.containsKey( matcher.group( 1 ) ) )
                    {
                        envItems.put( matcher.group( 1 ), entry.getValue().toString() );
                    }
                }
            }
        }
        return envItems;
    }

    /**
     * Determines whether these invoker properties contain a build definition for the specified invocation index.
     *
     * @param index The one-based index of the invocation to check for, must not be negative.
     * @return <code>true</code> if the invocation with the specified index is defined, <code>false</code> otherwise.
     */
    public boolean isInvocationDefined( int index )
    {
        return Arrays.stream( InvocationProperty.values() )
            .map( InvocationProperty::toString )
            .map( v -> properties.getProperty( v + '.' + index ) )
            .anyMatch( Objects::nonNull );
    }

    /**
     * Determines whether these invoker properties contain a build definition for the specified selector index.
     *
     * @param index the index
     * @return <code>true</code> if the selector with the specified index is defined, <code>false</code> otherwise.
     * @since 3.0.0
     */
    public boolean isSelectorDefined( int index )
    {
        return Arrays.stream( SelectorProperty.values() )
            .map( v -> v.suffix )
            .map( v -> properties.getProperty( SELECTOR_PREFIX + index + v ) )
            .anyMatch( Objects::nonNull );
    }

    private <T> void setIfNotNull( Consumer<T> consumer,  T value )
    {
        if ( value != null )
        {
            consumer.accept( value );
        }
    }

    /**
     * Configures the specified invocation request from these invoker properties. Settings not present in the invoker
     * properties will be left unchanged in the invocation request.
     *
     * @param request The invocation request to configure, must not be <code>null</code>.
     * @param index The one-based index of the invocation to configure, must not be negative.
     */
    public void configureInvocation( InvocationRequest request, int index )
    {
        get( InvocationProperty.PROJECT, index ).ifPresent( project ->
        {
            File file = new File( request.getBaseDirectory(), project );
            if ( file.isFile() )
            {
                request.setBaseDirectory( file.getParentFile() );
                request.setPomFile( file );
            }
            else
            {
                request.setBaseDirectory( file );
                request.setPomFile( null );
            }
        } );

        setIfNotNull( request::setGoals,  get( InvocationProperty.GOALS, index )
            .map( s -> StringUtils.split( s, ", \t\n\r\f" ) )
            .map( Arrays::asList )
            .filter( l -> !l.isEmpty() )
            .orElse( defaultGoals ) );

        setIfNotNull( request::setProfiles, get( InvocationProperty.PROFILES, index )
            .map( s -> StringUtils.split( s, ", \t\n\r\f" ) )
            .map( Arrays::asList )
            .filter( l -> !l.isEmpty() )
            .orElse( defaultProfiles ) );

        setIfNotNull( request::setMavenExecutable, get( InvocationProperty.MAVEN_EXECUTABLE, index )
            .map( File::new )
            .orElse( defaultMavenExecutable ) );

        setIfNotNull( request::setMavenOpts, get( InvocationProperty.MAVEN_OPTS, index ).orElse( defaultMavenOpts ) );

        get( InvocationProperty.FAILURE_BEHAVIOR, index )
            .map( InvocationRequest.ReactorFailureBehavior::valueOfByLongOption )
            .ifPresent( request::setReactorFailureBehavior );

        get( InvocationProperty.NON_RECURSIVE, index )
            .map( Boolean::parseBoolean )
            .map( b -> !b )
            .ifPresent( request::setRecursive );

        get( InvocationProperty.OFFLINE, index )
            .map( Boolean::parseBoolean )
            .ifPresent( request::setOffline );

        setIfNotNull( request::setDebug, get( InvocationProperty.DEBUG, index )
            .map( Boolean::parseBoolean )
            .orElse( defaultDebug ) );

        setIfNotNull( request::setQuiet, get( InvocationProperty.QUIET, index )
            .map( Boolean::parseBoolean )
            .orElse( defaultQuiet ) );

        setIfNotNull( request::setTimeoutInSeconds, get( InvocationProperty.TIMEOUT_IN_SECONDS, index )
            .map( Integer::parseInt )
            .orElse( defaultTimeoutInSeconds ) );

        Optional.ofNullable( defaultEnvironmentVariables )
                .ifPresent( evn -> evn.forEach( request::addShellEnvironment ) );

        getEnvironmentVariables( index )
            .forEach( request::addShellEnvironment );
    }

    /**
     * Checks whether the specified exit code matches the one expected for the given invocation.
     *
     * @param exitCode The exit code of the Maven invocation to check.
     * @param index The index of the invocation for which to check the exit code, must not be negative.
     * @return <code>true</code> if the exit code is zero and a success was expected or if the exit code is non-zero and
     *         a failue was expected, <code>false</code> otherwise.
     */
    public boolean isExpectedResult( int exitCode, int index )
    {
        boolean nonZeroExit = "failure".equalsIgnoreCase(
            get( InvocationProperty.BUILD_RESULT, index ).orElse( null ) );
        return ( exitCode != 0 ) == nonZeroExit;
    }

    /**
     * Gets the path to the properties file used to set the system properties for the specified invocation.
     *
     * @param index The index of the invocation, must not be negative.
     * @return The path to the properties file or <code>null</code> if not set.
     */
    public String getSystemPropertiesFile( int index )
    {
        return get( InvocationProperty.SYSTEM_PROPERTIES_FILE, index ).orElse( null );
    }

    /**
     * Gets the settings file used for the specified invocation.
     *
     * @param index The index of the invocation, must not be negative.
     * @return the value for the settings file or <code>null</code> if not set.
     */
    public String getSettingsFile( int index )
    {
        return get( InvocationProperty.SETTINGS_FILE, index ).orElse( null );
    }

    /**
     * Gets a value from the invoker properties. The invoker properties are intended to describe the invocation settings
     * for multiple builds of the same project. For this reason, the properties are indexed. First, a property named
     * <code>key.index</code> will be queried. If this property does not exist, the value of the property named
     * <code>key</code> will finally be returned.
     *
     * @param key The (base) key for the invoker property to lookup, must not be <code>null</code>.
     * @param index The index of the invocation for which to retrieve the value, must not be negative.
     * @return The value for the requested invoker property or <code>null</code> if not defined.
     */
    Optional<String> get( String key, int index )
    {
        if ( index < 0 )
        {
            throw new IllegalArgumentException( "invalid invocation index: " + index );
        }

        // lookup in properties
        String value = Optional.ofNullable( properties.getProperty( key + '.' + index ) )
            .orElseGet( () -> properties.getProperty( key ) );

        return Optional.ofNullable( value )
            .map( String::trim )
            .filter( s -> !s.isEmpty() );
    }

    private Optional<String> get( InvocationProperty prop, int index )
    {
        return get( prop.toString(), index );
    }
}