1 package org.apache.maven.shared.release;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.File;
23 import java.util.ArrayList;
24 import java.util.Collections;
25 import java.util.LinkedHashSet;
26 import java.util.List;
27 import java.util.Map;
28 import java.util.Set;
29
30 import org.apache.commons.lang.BooleanUtils;
31 import org.apache.maven.project.MavenProject;
32 import org.apache.maven.settings.Settings;
33 import org.apache.maven.shared.release.config.ReleaseDescriptor;
34 import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
35 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
36 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
37 import org.apache.maven.shared.release.env.ReleaseEnvironment;
38 import org.apache.maven.shared.release.phase.ReleasePhase;
39 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
40 import org.codehaus.plexus.logging.AbstractLogEnabled;
41 import org.codehaus.plexus.util.StringUtils;
42
43
44
45
46
47
48 public class DefaultReleaseManager
49 extends AbstractLogEnabled
50 implements ReleaseManager
51 {
52
53
54
55 private List<String> preparePhases;
56
57
58
59
60 private List<String> performPhases;
61
62
63
64
65 private List<String> rollbackPhases;
66
67
68
69
70 private List<String> branchPhases;
71
72
73
74
75 private List<String> updateVersionsPhases;
76
77
78
79
80 private Map<String, ReleasePhase> releasePhases;
81
82
83
84
85 private ReleaseDescriptorStore configStore;
86
87
88
89
90 private ScmRepositoryConfigurator scmRepositoryConfigurator;
91
92 private static final int PHASE_SKIP = 0, PHASE_START = 1, PHASE_END = 2, GOAL_START = 11, GOAL_END = 12, ERROR = 99;
93
94
95 public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
96 List<MavenProject> reactorProjects )
97 throws ReleaseExecutionException, ReleaseFailureException
98 {
99 prepare( releaseDescriptor, releaseEnvironment, reactorProjects, true, false, null );
100 }
101
102
103 public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
104 List<MavenProject> reactorProjects, boolean resume, boolean dryRun )
105 throws ReleaseExecutionException, ReleaseFailureException
106 {
107 prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, null );
108 }
109
110 public ReleaseResult prepareWithResult( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
111 List<MavenProject> reactorProjects, boolean resume, boolean dryRun,
112 ReleaseManagerListener listener )
113 {
114 ReleaseResult result = new ReleaseResult();
115
116 result.setStartTime( System.currentTimeMillis() );
117
118 try
119 {
120 prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, listener, result );
121
122 result.setResultCode( ReleaseResult.SUCCESS );
123 }
124 catch ( ReleaseExecutionException e )
125 {
126 captureException( result, listener, e );
127 }
128 catch ( ReleaseFailureException e )
129 {
130 captureException( result, listener, e );
131 }
132 finally
133 {
134 result.setEndTime( System.currentTimeMillis() );
135 }
136
137 return result;
138 }
139
140
141 public void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
142 List<MavenProject> reactorProjects, boolean resume, boolean dryRun,
143 ReleaseManagerListener listener )
144 throws ReleaseExecutionException, ReleaseFailureException
145 {
146 prepare( releaseDescriptor, releaseEnvironment, reactorProjects, resume, dryRun, listener, null );
147 }
148
149
150 public void prepare( ReleasePrepareRequest prepareRequest )
151 throws ReleaseExecutionException, ReleaseFailureException
152 {
153 prepare( prepareRequest, new ReleaseResult() );
154 }
155
156 private void prepare( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
157 List<MavenProject> reactorProjects, boolean resume, boolean dryRun,
158 ReleaseManagerListener listener, ReleaseResult result )
159 throws ReleaseExecutionException, ReleaseFailureException
160 {
161 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
162 prepareRequest.setReleaseDescriptor( releaseDescriptor );
163 prepareRequest.setReleaseEnvironment( releaseEnvironment );
164 prepareRequest.setReactorProjects( reactorProjects );
165 prepareRequest.setResume( resume );
166 prepareRequest.setDryRun( dryRun );
167 prepareRequest.setReleaseManagerListener( listener );
168
169 prepare( prepareRequest, result );
170 }
171
172 private void prepare( ReleasePrepareRequest prepareRequest, ReleaseResult result )
173 throws ReleaseExecutionException, ReleaseFailureException
174 {
175 updateListener( prepareRequest.getReleaseManagerListener(), "prepare", GOAL_START );
176
177 ReleaseDescriptor config;
178 if ( BooleanUtils.isNotFalse( prepareRequest.getResume() ) )
179 {
180 config = loadReleaseDescriptor( prepareRequest.getReleaseDescriptor(),
181 prepareRequest.getReleaseManagerListener() );
182 }
183 else
184 {
185 config = prepareRequest.getReleaseDescriptor();
186 }
187
188
189
190
191 String completedPhase = config.getCompletedPhase();
192 int index = preparePhases.indexOf( completedPhase );
193
194 for ( int idx = 0; idx <= index; idx++ )
195 {
196 updateListener( prepareRequest.getReleaseManagerListener(), preparePhases.get( idx ), PHASE_SKIP );
197 }
198
199 if ( index == preparePhases.size() - 1 )
200 {
201 logInfo( result, "Release preparation already completed. You can now continue with release:perform, "
202 + "or start again using the -Dresume=false flag" );
203 }
204 else if ( index >= 0 )
205 {
206 logInfo( result, "Resuming release from phase '" + preparePhases.get( index + 1 ) + "'" );
207 }
208
209
210 for ( int i = index + 1; i < preparePhases.size(); i++ )
211 {
212 String name = preparePhases.get( i );
213
214 ReleasePhase phase = releasePhases.get( name );
215
216 if ( phase == null )
217 {
218 throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
219 }
220
221 updateListener( prepareRequest.getReleaseManagerListener(), name, PHASE_START );
222
223 ReleaseResult phaseResult = null;
224 try
225 {
226 if ( BooleanUtils.isTrue( prepareRequest.getDryRun() ) )
227 {
228 phaseResult = phase.simulate( config,
229 prepareRequest.getReleaseEnvironment(),
230 prepareRequest.getReactorProjects() );
231 }
232 else
233 {
234 phaseResult = phase.execute( config,
235 prepareRequest.getReleaseEnvironment(),
236 prepareRequest.getReactorProjects() );
237 }
238 }
239 finally
240 {
241 if ( result != null && phaseResult != null )
242 {
243 result.appendOutput( phaseResult.getOutput() );
244 }
245 }
246
247 config.setCompletedPhase( name );
248 try
249 {
250 configStore.write( config );
251 }
252 catch ( ReleaseDescriptorStoreException e )
253 {
254
255 throw new ReleaseExecutionException( "Error writing release properties after completing phase", e );
256 }
257
258 updateListener( prepareRequest.getReleaseManagerListener(), name, PHASE_END );
259 }
260
261 updateListener( prepareRequest.getReleaseManagerListener(), "prepare", GOAL_END );
262 }
263
264
265 public void rollback( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
266 List<MavenProject> reactorProjects )
267 throws ReleaseExecutionException, ReleaseFailureException
268 {
269 rollback( releaseDescriptor, releaseEnvironment, reactorProjects, null );
270 }
271
272
273 public void rollback( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
274 List<MavenProject> reactorProjects, ReleaseManagerListener listener )
275 throws ReleaseExecutionException, ReleaseFailureException
276 {
277 ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
278 rollbackRequest.setReleaseDescriptor( releaseDescriptor );
279 rollbackRequest.setReleaseEnvironment( releaseEnvironment );
280 rollbackRequest.setReactorProjects( reactorProjects );
281 rollbackRequest.setReleaseManagerListener( listener );
282
283 rollback( rollbackRequest );
284 }
285
286
287 public void rollback( ReleaseRollbackRequest rollbackRequest )
288 throws ReleaseExecutionException, ReleaseFailureException
289 {
290 updateListener( rollbackRequest.getReleaseManagerListener(), "rollback", GOAL_START );
291
292 ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( rollbackRequest.getReleaseDescriptor(), null );
293
294 for ( String name : rollbackPhases )
295 {
296 ReleasePhase phase = releasePhases.get( name );
297
298 if ( phase == null )
299 {
300 throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
301 }
302
303 updateListener( rollbackRequest.getReleaseManagerListener(), name, PHASE_START );
304 phase.execute( releaseDescriptor,
305 rollbackRequest.getReleaseEnvironment(),
306 rollbackRequest.getReactorProjects() );
307 updateListener( rollbackRequest.getReleaseManagerListener(), name, PHASE_END );
308 }
309
310
311 clean( releaseDescriptor,
312 rollbackRequest.getReleaseManagerListener(),
313 rollbackRequest.getReactorProjects() );
314 updateListener( rollbackRequest.getReleaseManagerListener(), "rollback", GOAL_END );
315 }
316
317
318 public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
319 List<MavenProject> reactorProjects )
320 throws ReleaseExecutionException, ReleaseFailureException
321 {
322 perform( releaseDescriptor, releaseEnvironment, reactorProjects, null, true );
323 }
324
325
326 public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
327 List<MavenProject> reactorProjects, boolean clean )
328 throws ReleaseExecutionException, ReleaseFailureException
329 {
330 perform( releaseDescriptor, releaseEnvironment, reactorProjects, null, clean );
331 }
332
333
334 public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
335 List<MavenProject> reactorProjects, ReleaseManagerListener listener )
336 throws ReleaseExecutionException, ReleaseFailureException
337 {
338 perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, true );
339 }
340
341 public void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
342 List<MavenProject> reactorProjects, ReleaseManagerListener listener, boolean clean )
343 throws ReleaseExecutionException, ReleaseFailureException
344 {
345 perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, new ReleaseResult(), clean );
346 }
347
348 public ReleaseResult performWithResult( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
349 List<MavenProject> reactorProjects, ReleaseManagerListener listener )
350 {
351 ReleaseResult result = new ReleaseResult();
352
353 try
354 {
355 result.setStartTime( System.currentTimeMillis() );
356
357 perform( releaseDescriptor, releaseEnvironment, reactorProjects, listener, result, true );
358
359 result.setResultCode( ReleaseResult.SUCCESS );
360 }
361 catch ( ReleaseExecutionException e )
362 {
363 captureException( result, listener, e );
364 }
365 catch ( ReleaseFailureException e )
366 {
367 captureException( result, listener, e );
368 }
369 finally
370 {
371 result.setEndTime( System.currentTimeMillis() );
372 }
373
374 return result;
375 }
376
377
378 public void perform( ReleasePerformRequest performRequest )
379 throws ReleaseExecutionException, ReleaseFailureException
380 {
381 perform( performRequest, new ReleaseResult() );
382 }
383
384 private void perform( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
385 List<MavenProject> reactorProjects, ReleaseManagerListener listener, ReleaseResult result,
386 boolean clean )
387 throws ReleaseExecutionException, ReleaseFailureException
388 {
389 ReleasePerformRequest performRequest = new ReleasePerformRequest();
390 performRequest.setReleaseDescriptor( releaseDescriptor );
391 performRequest.setReleaseEnvironment( releaseEnvironment );
392 performRequest.setReactorProjects( reactorProjects );
393 performRequest.setReleaseManagerListener( listener );
394 performRequest.setClean( clean );
395
396 perform( performRequest, result );
397 }
398
399 private void perform( ReleasePerformRequest performRequest, ReleaseResult result )
400 throws ReleaseExecutionException, ReleaseFailureException
401 {
402 updateListener( performRequest.getReleaseManagerListener(), "perform", GOAL_START );
403
404 ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( performRequest.getReleaseDescriptor(),
405 performRequest.getReleaseManagerListener() );
406
407 for ( String name : performPhases )
408 {
409 ReleasePhase phase = releasePhases.get( name );
410
411 if ( phase == null )
412 {
413 throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
414 }
415
416 updateListener( performRequest.getReleaseManagerListener(), name, PHASE_START );
417
418 ReleaseResult phaseResult = null;
419 try
420 {
421 if ( BooleanUtils.isTrue( performRequest.getDryRun() ) )
422 {
423 phaseResult = phase.simulate( releaseDescriptor,
424 performRequest.getReleaseEnvironment(),
425 performRequest.getReactorProjects() );
426 }
427 else
428 {
429 phaseResult = phase.execute( releaseDescriptor,
430 performRequest.getReleaseEnvironment(),
431 performRequest.getReactorProjects() );
432 }
433 }
434 finally
435 {
436 if ( result != null && phaseResult != null )
437 {
438 result.appendOutput( phaseResult.getOutput() );
439 }
440 }
441
442 updateListener( performRequest.getReleaseManagerListener(), name, PHASE_END );
443 }
444
445 if ( BooleanUtils.isNotFalse( performRequest.getClean() ) )
446 {
447
448 clean( releaseDescriptor, performRequest.getReleaseManagerListener(), performRequest.getReactorProjects() );
449 }
450
451 updateListener( performRequest.getReleaseManagerListener(), "perform", GOAL_END );
452 }
453
454
455 public void branch( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
456 List<MavenProject> reactorProjects, boolean dryRun )
457 throws ReleaseExecutionException, ReleaseFailureException
458 {
459 branch( releaseDescriptor, releaseEnvironment, reactorProjects, dryRun, null );
460 }
461
462
463 public void branch( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
464 List<MavenProject> reactorProjects, boolean dryRun, ReleaseManagerListener listener )
465 throws ReleaseExecutionException, ReleaseFailureException
466 {
467 ReleaseBranchRequest branchRequest = new ReleaseBranchRequest();
468 branchRequest.setReleaseDescriptor( releaseDescriptor );
469 branchRequest.setReleaseEnvironment( releaseEnvironment );
470 branchRequest.setReactorProjects( reactorProjects );
471 branchRequest.setDryRun( dryRun );
472 branchRequest.setReleaseManagerListener( listener );
473
474 branch( branchRequest );
475 }
476
477
478 public void branch( ReleaseBranchRequest branchRequest )
479 throws ReleaseExecutionException, ReleaseFailureException
480 {
481 ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( branchRequest.getReleaseDescriptor(),
482 branchRequest.getReleaseManagerListener() );
483
484 updateListener( branchRequest.getReleaseManagerListener(), "branch", GOAL_START );
485
486 boolean dryRun = BooleanUtils.isTrue( branchRequest.getDryRun() );
487
488 for ( String name : branchPhases )
489 {
490 ReleasePhase phase = releasePhases.get( name );
491
492 if ( phase == null )
493 {
494 throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
495 }
496
497 updateListener( branchRequest.getReleaseManagerListener(), name, PHASE_START );
498
499 if ( dryRun )
500 {
501 phase.simulate( releaseDescriptor,
502 branchRequest.getReleaseEnvironment(),
503 branchRequest.getReactorProjects() );
504 }
505 else
506 {
507 phase.execute( releaseDescriptor,
508 branchRequest.getReleaseEnvironment(),
509 branchRequest.getReactorProjects() );
510 }
511 updateListener( branchRequest.getReleaseManagerListener(), name, PHASE_END );
512 }
513
514 if ( !dryRun )
515 {
516 clean( releaseDescriptor,
517 branchRequest.getReleaseManagerListener(),
518 branchRequest.getReactorProjects() );
519 }
520
521 updateListener( branchRequest.getReleaseManagerListener(), "branch", GOAL_END );
522 }
523
524 public void updateVersions( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
525 List<MavenProject> reactorProjects )
526 throws ReleaseExecutionException, ReleaseFailureException
527 {
528 ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
529 updateVersionsRequest.setReleaseDescriptor( releaseDescriptor );
530 updateVersionsRequest.setReleaseEnvironment( releaseEnvironment );
531 updateVersionsRequest.setReactorProjects( reactorProjects );
532
533 updateVersions( updateVersionsRequest );
534 }
535
536
537 public void updateVersions( ReleaseUpdateVersionsRequest updateVersionsRequest )
538 throws ReleaseExecutionException, ReleaseFailureException
539 {
540 updateListener( updateVersionsRequest.getReleaseManagerListener(), "updateVersions", GOAL_START );
541
542 ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( updateVersionsRequest.getReleaseDescriptor(),
543 updateVersionsRequest.getReleaseManagerListener() );
544
545 for ( String name : updateVersionsPhases )
546 {
547 ReleasePhase phase = releasePhases.get( name );
548
549 if ( phase == null )
550 {
551 throw new ReleaseExecutionException( "Unable to find phase '" + name + "' to execute" );
552 }
553
554 updateListener( updateVersionsRequest.getReleaseManagerListener(), name, PHASE_START );
555 phase.execute( releaseDescriptor,
556 updateVersionsRequest.getReleaseEnvironment(),
557 updateVersionsRequest.getReactorProjects() );
558 updateListener( updateVersionsRequest.getReleaseManagerListener(), name, PHASE_END );
559 }
560
561 clean( releaseDescriptor,
562 updateVersionsRequest.getReleaseManagerListener(),
563 updateVersionsRequest.getReactorProjects() );
564
565 updateListener( updateVersionsRequest.getReleaseManagerListener(), "updateVersions", GOAL_END );
566 }
567
568
569
570
571
572
573
574
575
576
577
578 protected File determineWorkingDirectory( File checkoutDirectory, String relativePathProjectDirectory )
579 {
580 if ( StringUtils.isNotEmpty( relativePathProjectDirectory ) )
581 {
582 return new File( checkoutDirectory, relativePathProjectDirectory );
583 }
584 else
585 {
586 return checkoutDirectory;
587 }
588 }
589
590 private ReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptor releaseDescriptor,
591 ReleaseManagerListener listener )
592 throws ReleaseExecutionException
593 {
594 try
595 {
596 updateListener( listener, "verify-release-configuration", PHASE_START );
597 ReleaseDescriptor descriptor = configStore.read( releaseDescriptor );
598 updateListener( listener, "verify-release-configuration", PHASE_END );
599 return descriptor;
600 }
601 catch ( ReleaseDescriptorStoreException e )
602 {
603 updateListener( listener, e.getMessage(), ERROR );
604
605 throw new ReleaseExecutionException( "Error reading stored configuration: " + e.getMessage(), e );
606 }
607 }
608
609
610 public void clean( ReleaseDescriptor releaseDescriptor, ReleaseManagerListener listener,
611 List<MavenProject> reactorProjects )
612 {
613 ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
614 cleanRequest.setReleaseDescriptor( releaseDescriptor );
615 cleanRequest.setReleaseManagerListener( listener );
616 cleanRequest.setReactorProjects( reactorProjects );
617
618 clean( cleanRequest );
619 }
620
621
622 public void clean( ReleaseCleanRequest cleanRequest )
623 {
624 updateListener( cleanRequest.getReleaseManagerListener(), "cleanup", PHASE_START );
625
626 getLogger().info( "Cleaning up after release..." );
627
628 configStore.delete( cleanRequest.getReleaseDescriptor() );
629 Set<String> phases = new LinkedHashSet<String>( preparePhases );
630 phases.addAll( branchPhases );
631
632 for ( String name : phases )
633 {
634 ReleasePhase phase = releasePhases.get( name );
635
636 phase.clean( cleanRequest.getReactorProjects() );
637 }
638
639 updateListener( cleanRequest.getReleaseManagerListener(), "cleanup", PHASE_END );
640 }
641
642 void setConfigStore( ReleaseDescriptorStore configStore )
643 {
644 this.configStore = configStore;
645 }
646
647 void updateListener( ReleaseManagerListener listener, String name, int state )
648 {
649 if ( listener != null )
650 {
651 switch ( state )
652 {
653 case GOAL_START:
654 listener.goalStart( name, getGoalPhases( name ) );
655 break;
656 case GOAL_END:
657 listener.goalEnd();
658 break;
659 case PHASE_SKIP:
660 listener.phaseSkip( name );
661 break;
662 case PHASE_START:
663 listener.phaseStart( name );
664 break;
665 case PHASE_END:
666 listener.phaseEnd();
667 break;
668 default:
669 listener.error( name );
670 }
671 }
672 }
673
674 private List<String> getGoalPhases( String name )
675 {
676 List<String> phases = new ArrayList<String>();
677
678 if ( "prepare".equals( name ) )
679 {
680 phases.addAll( preparePhases );
681 }
682 else if ( "perform".equals( name ) )
683 {
684 phases.addAll( performPhases );
685 }
686 else if ( "rollback".equals( name ) )
687 {
688 phases.addAll( rollbackPhases );
689 }
690 else if ( "branch".equals( name ) )
691 {
692 phases.addAll( branchPhases );
693 }
694 else if ( "updateVersions".equals( name ) )
695 {
696 phases.addAll( updateVersionsPhases );
697 }
698
699 return Collections.unmodifiableList( phases );
700 }
701
702 private void logInfo( ReleaseResult result, String message )
703 {
704 if ( result != null )
705 {
706 result.appendInfo( message );
707 }
708
709 getLogger().info( message );
710 }
711
712 private void captureException( ReleaseResult result, ReleaseManagerListener listener, Exception e )
713 {
714 updateListener( listener, e.getMessage(), ERROR );
715
716 result.appendError( e );
717
718 result.setResultCode( ReleaseResult.ERROR );
719 }
720
721
722 public void branch( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
723 boolean dryRun )
724 throws ReleaseExecutionException, ReleaseFailureException
725 {
726 branch( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, dryRun );
727 }
728
729
730 public void branch( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
731 boolean dryRun, ReleaseManagerListener listener )
732 throws ReleaseExecutionException, ReleaseFailureException
733 {
734 branch( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, dryRun,
735 listener );
736 }
737
738
739 public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects )
740 throws ReleaseExecutionException, ReleaseFailureException
741 {
742 perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects );
743 }
744
745
746 public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
747 ReleaseManagerListener listener )
748 throws ReleaseExecutionException, ReleaseFailureException
749 {
750 perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, listener );
751 }
752
753
754 public void perform( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
755 boolean clean )
756 throws ReleaseExecutionException, ReleaseFailureException
757 {
758 perform( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, clean );
759 }
760
761 public ReleaseResult performWithResult( ReleaseDescriptor releaseDescriptor, Settings settings,
762 List<MavenProject> reactorProjects, ReleaseManagerListener listener )
763 {
764 return performWithResult( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ),
765 reactorProjects, listener );
766 }
767
768
769 public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects )
770 throws ReleaseExecutionException, ReleaseFailureException
771 {
772 prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects );
773 }
774
775
776 public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
777 boolean resume, boolean dryRun )
778 throws ReleaseExecutionException, ReleaseFailureException
779 {
780 prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, resume,
781 dryRun );
782 }
783
784
785 public void prepare( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
786 boolean resume, boolean dryRun, ReleaseManagerListener listener )
787 throws ReleaseExecutionException, ReleaseFailureException
788 {
789 prepare( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, resume,
790 dryRun, listener );
791 }
792
793 public ReleaseResult prepareWithResult( ReleaseDescriptor releaseDescriptor, Settings settings,
794 List<MavenProject> reactorProjects, boolean resume, boolean dryRun,
795 ReleaseManagerListener listener )
796 {
797 return prepareWithResult( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ),
798 reactorProjects, resume, dryRun, listener );
799 }
800
801
802 public void rollback( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects,
803 ReleaseManagerListener listener )
804 throws ReleaseExecutionException, ReleaseFailureException
805 {
806 rollback( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, listener );
807 }
808
809
810 public void rollback( ReleaseDescriptor releaseDescriptor, Settings settings, List<MavenProject> reactorProjects )
811 throws ReleaseExecutionException, ReleaseFailureException
812 {
813 rollback( releaseDescriptor, new DefaultReleaseEnvironment().setSettings( settings ), reactorProjects, null );
814 }
815 }