Java tutorial
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 <a href="mailto:brett@apache.org">Brett Porter</a> */ public class DefaultReleaseManager extends AbstractLogEnabled implements ReleaseManager { /** * The phases of release to run, and in what order. */ private List<String> preparePhases; /** * The phases of release to run to perform. */ private List<String> performPhases; /** * The phases of release to run to rollback changes */ private List<String> rollbackPhases; /** * The phases to create a branch. */ private List<String> branchPhases; /** * The phases to create update versions. */ private List<String> updateVersionsPhases; /** * The available phases. */ private Map<String, ReleasePhase> 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<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { prepare(releaseDescriptor, releaseEnvironment, reactorProjects, true, false, null); } /** {@inheritDoc} */ public void prepare(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> reactorProjects, boolean resume, boolean dryRun) throws ReleaseExecutionException, ReleaseFailureException { prepare(releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, null); } public ReleaseResult prepareWithResult(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> 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<MavenProject> 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<MavenProject> 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<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { rollback(releaseDescriptor, releaseEnvironment, reactorProjects, null); } /** {@inheritDoc} */ public void rollback(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> 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<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, releaseEnvironment, reactorProjects, null, true); } /** {@inheritDoc} */ public void perform(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> reactorProjects, boolean clean) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, releaseEnvironment, reactorProjects, null, clean); } /** {@inheritDoc} */ public void perform(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> reactorProjects, ReleaseManagerListener listener) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, releaseEnvironment, reactorProjects, listener, true); } public void perform(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> reactorProjects, ReleaseManagerListener listener, boolean clean) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, releaseEnvironment, reactorProjects, listener, new ReleaseResult(), clean); } public ReleaseResult performWithResult(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> 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<MavenProject> 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<MavenProject> reactorProjects, boolean dryRun) throws ReleaseExecutionException, ReleaseFailureException { branch(releaseDescriptor, releaseEnvironment, reactorProjects, dryRun, null); } /** {@inheritDoc} */ public void branch(ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment, List<MavenProject> 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<MavenProject> 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<MavenProject> 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<String> phases = new LinkedHashSet<String>(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<String> getGoalPhases(String name) { List<String> phases = new ArrayList<String>(); 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<MavenProject> reactorProjects, boolean dryRun) throws ReleaseExecutionException, ReleaseFailureException { branch(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, dryRun); } /** {@inheritDoc} */ public void branch(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> 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<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects); } /** {@inheritDoc} */ public void perform(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects, ReleaseManagerListener listener) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, listener); } /** {@inheritDoc} */ public void perform(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects, boolean clean) throws ReleaseExecutionException, ReleaseFailureException { perform(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, clean); } public ReleaseResult performWithResult(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects, ReleaseManagerListener listener) { return performWithResult(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, listener); } /** {@inheritDoc} */ public void prepare(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { prepare(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects); } /** {@inheritDoc} */ public void prepare(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> 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<MavenProject> 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<MavenProject> 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<MavenProject> reactorProjects, ReleaseManagerListener listener) throws ReleaseExecutionException, ReleaseFailureException { rollback(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, listener); } /** {@inheritDoc} */ public void rollback(ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects) throws ReleaseExecutionException, ReleaseFailureException { rollback(releaseDescriptor, new DefaultReleaseEnvironment().setSettings(settings), reactorProjects, null); } }