org.apache.maven.shared.release.DefaultReleaseManager Maven / Gradle / Ivy
package org.apache.maven.shared.release;
/*
* 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.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.BooleanUtils;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.apache.maven.shared.release.config.ReleaseDescriptor;
import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.apache.maven.shared.release.phase.ReleasePhase;
import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.StringUtils;
/**
* Implementation of the release manager.
*
* @author Brett Porter
*/
public class DefaultReleaseManager
extends AbstractLogEnabled
implements ReleaseManager
{
/**
* The phases of release to run, and in what order.
*/
private List preparePhases;
/**
* The phases of release to run to perform.
*/
private List performPhases;
/**
* The phases of release to run to rollback changes
*/
private List rollbackPhases;
/**
* The phases to create a branch.
*/
private List branchPhases;
/**
* The phases to create update versions.
*/
private List updateVersionsPhases;
/**
* The available phases.
*/
private Map releasePhases;
/**
* The configuration storage.
*/
private ReleaseDescriptorStore configStore;
/**
* Tool for configuring SCM repositories from release configuration.
*/
private ScmRepositoryConfigurator scmRepositoryConfigurator;
private static final int PHASE_SKIP = 0, PHASE_START = 1, PHASE_END = 2, GOAL_START = 11, GOAL_END = 12, ERROR = 99;
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, releaseEnvironment, reactorProjects, true, false, null );
}
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean resume, boolean dryRun )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, null );
}
public ReleaseResult prepareWithResult( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean resume, boolean dryRun,
ReleaseManagerListener listener )
{
ReleaseResult result = new ReleaseResult();
result.setStartTime( System.currentTimeMillis() );
try
{
prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, listener, result );
result.setResultCode( ReleaseResult.SUCCESS );
}
catch ( ReleaseExecutionException e )
{
captureException( result, listener, e );
}
catch ( ReleaseFailureException e )
{
captureException( result, listener, e );
}
finally
{
result.setEndTime( System.currentTimeMillis() );
}
return result;
}
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean resume, boolean dryRun,
ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, listener, null );
}
/** {@inheritDoc} */
public void prepare( ReleasePrepareRequest prepareRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( prepareRequest, new ReleaseResult() );
}
private void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean resume, boolean dryRun,
ReleaseManagerListener listener, ReleaseResult result )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
prepareRequest.setReleaseDescriptor( releaseDescriptor );
prepareRequest.setReleaseEnvironment( releaseEnvironment );
prepareRequest.setReactorProjects( reactorProjects );
prepareRequest.setResume( resume );
prepareRequest.setDryRun( dryRun );
prepareRequest.setReleaseManagerListener( listener );
prepare( prepareRequest, result );
}
private void prepare( ReleasePrepareRequest prepareRequest, ReleaseResult result )
throws ReleaseExecutionException, ReleaseFailureException
{
updateListener( prepareRequest.getReleaseManagerListener(), "prepare", GOAL_START );
ReleaseDescriptor config;
if ( BooleanUtils.isNotFalse( prepareRequest.getResume() ) )
{
config = loadReleaseDescriptor( prepareRequest.getReleaseDescriptor(),
prepareRequest.getReleaseManagerListener() );
}
else
{
config = prepareRequest.getReleaseDescriptor();
}
// Later, it would be a good idea to introduce a proper workflow tool so that the release can be made up of a
// more flexible set of steps.
String completedPhase = config.getCompletedPhase();
int index = preparePhases.indexOf( completedPhase );
for ( int idx = 0; idx <= index; idx++ )
{
updateListener( prepareRequest.getReleaseManagerListener(), preparePhases.get( idx ), PHASE_SKIP );
}
if ( index == preparePhases.size() - 1 )
{
logInfo( result, "Release preparation already completed. You can now continue with release:perform, "
+ "or start again using the -Dresume=false flag" );
}
else if ( index >= 0 )
{
logInfo( result, "Resuming release from phase '" + preparePhases.get( index + 1 ) + "'" );
}
// start from next phase
for ( int i = index + 1; i < preparePhases.size(); i++ )
{
String name = preparePhases.get( i );
ReleasePhase phase = releasePhases.get( name );
if ( phase == null )
{
throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
}
updateListener( prepareRequest.getReleaseManagerListener(), name, PHASE_START );
ReleaseResult phaseResult = null;
try
{
if ( BooleanUtils.isTrue( prepareRequest.getDryRun() ) )
{
phaseResult = phase.simulate( config,
prepareRequest.getReleaseEnvironment(),
prepareRequest.getReactorProjects() );
}
else
{
phaseResult = phase.execute( config,
prepareRequest.getReleaseEnvironment(),
prepareRequest.getReactorProjects() );
}
}
finally
{
if ( result != null && phaseResult != null )
{
result.appendOutput( phaseResult.getOutput() );
}
}
config.setCompletedPhase( name );
try
{
configStore.write( config );
}
catch ( ReleaseDescriptorStoreException e )
{
// TODO: rollback?
throw new ReleaseExecutionException( "Error writing release properties after completing phase", e );
}
updateListener( prepareRequest.getReleaseManagerListener(), name, PHASE_END );
}
updateListener( prepareRequest.getReleaseManagerListener(), "prepare", GOAL_END );
}
/** {@inheritDoc} */
public void rollback( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
rollback( releaseDescriptor, releaseEnvironment, reactorProjects, null );
}
/** {@inheritDoc} */
public void rollback( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
rollbackRequest.setReleaseDescriptor( releaseDescriptor );
rollbackRequest.setReleaseEnvironment( releaseEnvironment );
rollbackRequest.setReactorProjects( reactorProjects );
rollbackRequest.setReleaseManagerListener( listener );
rollback( rollbackRequest );
}
/** {@inheritDoc} */
public void rollback( ReleaseRollbackRequest rollbackRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
updateListener( rollbackRequest.getReleaseManagerListener(), "rollback", GOAL_START );
ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( rollbackRequest.getReleaseDescriptor(), null );
for ( String name : rollbackPhases )
{
ReleasePhase phase = releasePhases.get( name );
if ( phase == null )
{
throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
}
updateListener( rollbackRequest.getReleaseManagerListener(), name, PHASE_START );
phase.execute( releaseDescriptor,
rollbackRequest.getReleaseEnvironment(),
rollbackRequest.getReactorProjects() );
updateListener( rollbackRequest.getReleaseManagerListener(), name, PHASE_END );
}
//call release:clean so that resume will not be possible anymore after a rollback
clean( releaseDescriptor,
rollbackRequest.getReleaseManagerListener(),
rollbackRequest.getReactorProjects() );
updateListener( rollbackRequest.getReleaseManagerListener(), "rollback", GOAL_END );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, releaseEnvironment, reactorProjects, null, true );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean clean )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, releaseEnvironment, reactorProjects, null, clean );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, true );
}
public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, ReleaseManagerListener listener, boolean clean )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, new ReleaseResult(), clean );
}
public ReleaseResult performWithResult( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, ReleaseManagerListener listener )
{
ReleaseResult result = new ReleaseResult();
try
{
result.setStartTime( System.currentTimeMillis() );
perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, result, true );
result.setResultCode( ReleaseResult.SUCCESS );
}
catch ( ReleaseExecutionException e )
{
captureException( result, listener, e );
}
catch ( ReleaseFailureException e )
{
captureException( result, listener, e );
}
finally
{
result.setEndTime( System.currentTimeMillis() );
}
return result;
}
/** {@inheritDoc} */
public void perform( ReleasePerformRequest performRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( performRequest, new ReleaseResult() );
}
private void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, ReleaseManagerListener listener, ReleaseResult result,
boolean clean )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleasePerformRequest performRequest = new ReleasePerformRequest();
performRequest.setReleaseDescriptor( releaseDescriptor );
performRequest.setReleaseEnvironment( releaseEnvironment );
performRequest.setReactorProjects( reactorProjects );
performRequest.setReleaseManagerListener( listener );
performRequest.setClean( clean );
perform( performRequest, result );
}
private void perform( ReleasePerformRequest performRequest, ReleaseResult result )
throws ReleaseExecutionException, ReleaseFailureException
{
updateListener( performRequest.getReleaseManagerListener(), "perform", GOAL_START );
ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( performRequest.getReleaseDescriptor(),
performRequest.getReleaseManagerListener() );
for ( String name : performPhases )
{
ReleasePhase phase = releasePhases.get( name );
if ( phase == null )
{
throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
}
updateListener( performRequest.getReleaseManagerListener(), name, PHASE_START );
ReleaseResult phaseResult = null;
try
{
if ( BooleanUtils.isTrue( performRequest.getDryRun() ) )
{
phaseResult = phase.simulate( releaseDescriptor,
performRequest.getReleaseEnvironment(),
performRequest.getReactorProjects() );
}
else
{
phaseResult = phase.execute( releaseDescriptor,
performRequest.getReleaseEnvironment(),
performRequest.getReactorProjects() );
}
}
finally
{
if ( result != null && phaseResult != null )
{
result.appendOutput( phaseResult.getOutput() );
}
}
updateListener( performRequest.getReleaseManagerListener(), name, PHASE_END );
}
if ( BooleanUtils.isNotFalse( performRequest.getClean() ) )
{
// call release:clean so that resume will not be possible anymore after a perform
clean( releaseDescriptor, performRequest.getReleaseManagerListener(), performRequest.getReactorProjects() );
}
updateListener( performRequest.getReleaseManagerListener(), "perform", GOAL_END );
}
/** {@inheritDoc} */
public void branch( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean dryRun )
throws ReleaseExecutionException, ReleaseFailureException
{
branch( releaseDescriptor, releaseEnvironment, reactorProjects, dryRun, null );
}
/** {@inheritDoc} */
public void branch( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects, boolean dryRun, ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleaseBranchRequest branchRequest = new ReleaseBranchRequest();
branchRequest.setReleaseDescriptor( releaseDescriptor );
branchRequest.setReleaseEnvironment( releaseEnvironment );
branchRequest.setReactorProjects( reactorProjects );
branchRequest.setDryRun( dryRun );
branchRequest.setReleaseManagerListener( listener );
branch( branchRequest );
}
/** {@inheritDoc} */
public void branch( ReleaseBranchRequest branchRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( branchRequest.getReleaseDescriptor(),
branchRequest.getReleaseManagerListener() );
updateListener( branchRequest.getReleaseManagerListener(), "branch", GOAL_START );
boolean dryRun = BooleanUtils.isTrue( branchRequest.getDryRun() );
for ( String name : branchPhases )
{
ReleasePhase phase = releasePhases.get( name );
if ( phase == null )
{
throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
}
updateListener( branchRequest.getReleaseManagerListener(), name, PHASE_START );
if ( dryRun )
{
phase.simulate( releaseDescriptor,
branchRequest.getReleaseEnvironment(),
branchRequest.getReactorProjects() );
}
else // getDryRun is null or FALSE
{
phase.execute( releaseDescriptor,
branchRequest.getReleaseEnvironment(),
branchRequest.getReactorProjects() );
}
updateListener( branchRequest.getReleaseManagerListener(), name, PHASE_END );
}
if ( !dryRun )
{
clean( releaseDescriptor,
branchRequest.getReleaseManagerListener(),
branchRequest.getReactorProjects() );
}
updateListener( branchRequest.getReleaseManagerListener(), "branch", GOAL_END );
}
public void updateVersions( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
updateVersionsRequest.setReleaseDescriptor( releaseDescriptor );
updateVersionsRequest.setReleaseEnvironment( releaseEnvironment );
updateVersionsRequest.setReactorProjects( reactorProjects );
updateVersions( updateVersionsRequest );
}
/** {@inheritDoc} */
public void updateVersions( ReleaseUpdateVersionsRequest updateVersionsRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
updateListener( updateVersionsRequest.getReleaseManagerListener(), "updateVersions", GOAL_START );
ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( updateVersionsRequest.getReleaseDescriptor(),
updateVersionsRequest.getReleaseManagerListener() );
for ( String name : updateVersionsPhases )
{
ReleasePhase phase = releasePhases.get( name );
if ( phase == null )
{
throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
}
updateListener( updateVersionsRequest.getReleaseManagerListener(), name, PHASE_START );
phase.execute( releaseDescriptor,
updateVersionsRequest.getReleaseEnvironment(),
updateVersionsRequest.getReactorProjects() );
updateListener( updateVersionsRequest.getReleaseManagerListener(), name, PHASE_END );
}
clean( releaseDescriptor,
updateVersionsRequest.getReleaseManagerListener(),
updateVersionsRequest.getReactorProjects() );
updateListener( updateVersionsRequest.getReleaseManagerListener(), "updateVersions", GOAL_END );
}
/**
* Determines the path of the working directory. By default, this is the
* checkout directory. For some SCMs, the project root directory is not the
* checkout directory itself, but a SCM-specific subdirectory.
*
* @param checkoutDirectory The checkout directory as java.io.File
* @param relativePathProjectDirectory The relative path of the project directory within the checkout
* directory or ""
* @return The working directory
*/
protected File determineWorkingDirectory( File checkoutDirectory, String relativePathProjectDirectory )
{
if ( StringUtils.isNotEmpty( relativePathProjectDirectory ) )
{
return new File( checkoutDirectory, relativePathProjectDirectory );
}
else
{
return checkoutDirectory;
}
}
private ReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptor releaseDescriptor,
ReleaseManagerListener listener )
throws ReleaseExecutionException
{
try
{
updateListener( listener, "verify-release-configuration", PHASE_START );
ReleaseDescriptor descriptor = configStore.read( releaseDescriptor );
updateListener( listener, "verify-release-configuration", PHASE_END );
return descriptor;
}
catch ( ReleaseDescriptorStoreException e )
{
updateListener( listener, e.getMessage(), ERROR );
throw new ReleaseExecutionException( "Error reading stored configuration: " + e.getMessage(), e );
}
}
/** {@inheritDoc} */
public void clean( ReleaseDescriptor releaseDescriptor, ReleaseManagerListener listener,
List reactorProjects )
{
ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
cleanRequest.setReleaseDescriptor( releaseDescriptor );
cleanRequest.setReleaseManagerListener( listener );
cleanRequest.setReactorProjects( reactorProjects );
clean( cleanRequest );
}
/** {@inheritDoc} */
public void clean( ReleaseCleanRequest cleanRequest )
{
updateListener( cleanRequest.getReleaseManagerListener(), "cleanup", PHASE_START );
getLogger().info( "Cleaning up after release..." );
configStore.delete( cleanRequest.getReleaseDescriptor() );
Set phases = new LinkedHashSet( preparePhases );
phases.addAll( branchPhases );
for ( String name : phases )
{
ReleasePhase phase = releasePhases.get( name );
phase.clean( cleanRequest.getReactorProjects() );
}
updateListener( cleanRequest.getReleaseManagerListener(), "cleanup", PHASE_END );
}
void setConfigStore( ReleaseDescriptorStore configStore )
{
this.configStore = configStore;
}
void updateListener( ReleaseManagerListener listener, String name, int state )
{
if ( listener != null )
{
switch ( state )
{
case GOAL_START:
listener.goalStart( name, getGoalPhases( name ) );
break;
case GOAL_END:
listener.goalEnd();
break;
case PHASE_SKIP:
listener.phaseSkip( name );
break;
case PHASE_START:
listener.phaseStart( name );
break;
case PHASE_END:
listener.phaseEnd();
break;
default:
listener.error( name );
}
}
}
private List getGoalPhases( String name )
{
List phases = new ArrayList();
if ( "prepare".equals( name ) )
{
phases.addAll( preparePhases );
}
else if ( "perform".equals( name ) )
{
phases.addAll( performPhases );
}
else if ( "rollback".equals( name ) )
{
phases.addAll( rollbackPhases );
}
else if ( "branch".equals( name ) )
{
phases.addAll( branchPhases );
}
else if ( "updateVersions".equals( name ) )
{
phases.addAll( updateVersionsPhases );
}
return Collections.unmodifiableList( phases );
}
private void logInfo( ReleaseResult result, String message )
{
if ( result != null )
{
result.appendInfo( message );
}
getLogger().info( message );
}
private void captureException( ReleaseResult result, ReleaseManagerListener listener, Exception e )
{
updateListener( listener, e.getMessage(), ERROR );
result.appendError( e );
result.setResultCode( ReleaseResult.ERROR );
}
/** {@inheritDoc} */
public void branch( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
boolean dryRun )
throws ReleaseExecutionException, ReleaseFailureException
{
branch( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, dryRun );
}
/** {@inheritDoc} */
public void branch( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
boolean dryRun, ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
branch( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, dryRun,
listener );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, listener );
}
/** {@inheritDoc} */
public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
boolean clean )
throws ReleaseExecutionException, ReleaseFailureException
{
perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, clean );
}
public ReleaseResult performWithResult( ReleaseDescriptor releaseDescriptor, Settings settings,
List reactorProjects, ReleaseManagerListener listener )
{
return performWithResult( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ),
reactorProjects, listener );
}
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects );
}
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
boolean resume, boolean dryRun )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, resume,
dryRun );
}
/** {@inheritDoc} */
public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
boolean resume, boolean dryRun, ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, resume,
dryRun, listener );
}
public ReleaseResult prepareWithResult( ReleaseDescriptor releaseDescriptor, Settings settings,
List reactorProjects, boolean resume, boolean dryRun,
ReleaseManagerListener listener )
{
return prepareWithResult( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ),
reactorProjects, resume, dryRun, listener );
}
/** {@inheritDoc} */
public void rollback( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects,
ReleaseManagerListener listener )
throws ReleaseExecutionException, ReleaseFailureException
{
rollback( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, listener );
}
/** {@inheritDoc} */
public void rollback( ReleaseDescriptor releaseDescriptor, Settings settings, List reactorProjects )
throws ReleaseExecutionException, ReleaseFailureException
{
rollback( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, null );
}
} © 2015 - 2024 Weber Informatics LLC | Privacy Policy