1 package org.apache.maven.shared.release.phase;
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.io.IOException;
24 import java.io.Writer;
25 import java.nio.file.Path;
26 import java.util.ArrayList;
27 import java.util.Collections;
28 import java.util.LinkedHashMap;
29 import java.util.List;
30 import java.util.Map;
31 import java.util.Properties;
32 import java.util.Set;
33
34 import org.apache.maven.artifact.Artifact;
35 import org.apache.maven.artifact.ArtifactUtils;
36 import org.apache.maven.model.Build;
37 import org.apache.maven.model.Dependency;
38 import org.apache.maven.model.Extension;
39 import org.apache.maven.model.Model;
40 import org.apache.maven.model.Plugin;
41 import org.apache.maven.model.Profile;
42 import org.apache.maven.model.ReportPlugin;
43 import org.apache.maven.model.Reporting;
44 import org.apache.maven.model.Resource;
45 import org.apache.maven.model.Scm;
46 import org.apache.maven.model.building.DefaultModelBuildingRequest;
47 import org.apache.maven.model.building.ModelBuildingRequest;
48 import org.apache.maven.model.interpolation.ModelInterpolator;
49 import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
50 import org.apache.maven.model.superpom.SuperPomProvider;
51 import org.apache.maven.project.MavenProject;
52 import org.apache.maven.scm.ScmException;
53 import org.apache.maven.scm.ScmFileSet;
54 import org.apache.maven.scm.command.add.AddScmResult;
55 import org.apache.maven.scm.provider.ScmProvider;
56 import org.apache.maven.scm.repository.ScmRepository;
57 import org.apache.maven.shared.release.ReleaseExecutionException;
58 import org.apache.maven.shared.release.ReleaseFailureException;
59 import org.apache.maven.shared.release.ReleaseResult;
60 import org.apache.maven.shared.release.config.ReleaseDescriptor;
61 import org.apache.maven.shared.release.env.ReleaseEnvironment;
62 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
63 import org.apache.maven.shared.release.scm.ScmTranslator;
64 import org.apache.maven.shared.release.util.ReleaseUtil;
65 import org.codehaus.plexus.component.annotations.Component;
66 import org.codehaus.plexus.component.annotations.Requirement;
67 import org.codehaus.plexus.util.WriterFactory;
68
69
70
71
72
73
74
75 @Component( role = ReleasePhase.class, hint = "generate-release-poms" )
76 public class GenerateReleasePomsPhase
77 extends AbstractReleasePomsPhase implements ResourceGenerator
78 {
79 private static final String FINALNAME_EXPRESSION = "${project.artifactId}-${project.version}";
80
81 @Requirement
82 private SuperPomProvider superPomProvider;
83
84 @Requirement
85 private ModelInterpolator modelInterpolator;
86
87
88
89
90 @Requirement( role = ScmTranslator.class )
91 private Map<String, ScmTranslator> scmTranslators;
92
93
94
95
96
97 @Override
98 public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
99 List<MavenProject> reactorProjects )
100 throws ReleaseExecutionException, ReleaseFailureException
101 {
102 return execute( releaseDescriptor, releaseEnvironment, reactorProjects, false );
103 }
104
105 private ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
106 List<MavenProject> reactorProjects, boolean simulate )
107 throws ReleaseExecutionException, ReleaseFailureException
108 {
109 ReleaseResult result = new ReleaseResult();
110
111 if ( releaseDescriptor.isGenerateReleasePoms() )
112 {
113 logInfo( result, "Generating release POMs..." );
114
115 generateReleasePoms( releaseDescriptor, releaseEnvironment, reactorProjects, simulate, result );
116 }
117 else
118 {
119 logInfo( result, "Not generating release POMs" );
120 }
121
122 result.setResultCode( ReleaseResult.SUCCESS );
123
124 return result;
125 }
126
127 private void generateReleasePoms( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
128 List<MavenProject> reactorProjects, boolean simulate, ReleaseResult result )
129 throws ReleaseExecutionException, ReleaseFailureException
130 {
131 List<File> releasePoms = new ArrayList<>();
132
133 for ( MavenProject project : reactorProjects )
134 {
135 logInfo( result, "Generating release POM for '" + project.getName() + "'..." );
136
137 releasePoms.add( generateReleasePom( project, releaseDescriptor, releaseEnvironment, result ) );
138 }
139
140 addReleasePomsToScm( releaseDescriptor, releaseEnvironment, reactorProjects, simulate, result, releasePoms );
141 }
142
143 private File generateReleasePom( MavenProject project, ReleaseDescriptor releaseDescriptor,
144 ReleaseEnvironment releaseEnvironment,
145 ReleaseResult result )
146 throws ReleaseExecutionException, ReleaseFailureException
147 {
148
149
150 Model releasePom = createReleaseModel( project, releaseDescriptor, releaseEnvironment, result );
151
152
153
154 MavenXpp3Writer pomWriter = new MavenXpp3Writer();
155
156 File releasePomFile = ReleaseUtil.getReleasePom( project );
157
158
159 if ( releasePomFile == null )
160 {
161 throw new ReleaseExecutionException( "Cannot generate release POM : pom file is null" );
162 }
163
164
165
166 try ( Writer fileWriter = WriterFactory.newXmlWriter( releasePomFile ) )
167 {
168 pomWriter.write( fileWriter, releasePom );
169 }
170 catch ( IOException exception )
171 {
172 throw new ReleaseExecutionException( "Cannot generate release POM", exception );
173 }
174
175 return releasePomFile;
176 }
177
178 private void addReleasePomsToScm( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
179 List<MavenProject> reactorProjects, boolean simulate, ReleaseResult result,
180 List<File> releasePoms )
181 throws ReleaseFailureException, ReleaseExecutionException
182 {
183 if ( simulate )
184 {
185 logInfo( result, "Full run would be adding " + releasePoms );
186 }
187 else
188 {
189 ScmRepository scmRepository = getScmRepository( releaseDescriptor, releaseEnvironment );
190 ScmProvider scmProvider = getScmProvider( scmRepository );
191
192 MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
193 ScmFileSet scmFileSet = new ScmFileSet( rootProject.getFile().getParentFile(), releasePoms );
194
195 try
196 {
197 AddScmResult scmResult = scmProvider.add( scmRepository, scmFileSet );
198
199 if ( !scmResult.isSuccess() )
200 {
201 throw new ReleaseScmCommandException( "Cannot add release POM to SCM", scmResult );
202 }
203 }
204 catch ( ScmException exception )
205 {
206 throw new ReleaseExecutionException( "Cannot add release POM to SCM: " + exception.getMessage(),
207 exception );
208 }
209 }
210 }
211
212 private Model createReleaseModel( MavenProject project, ReleaseDescriptor releaseDescriptor,
213 ReleaseEnvironment releaseEnvironment,
214 ReleaseResult result )
215 throws ReleaseFailureException, ReleaseExecutionException
216 {
217 MavenProject releaseProject = project.clone();
218 Model releaseModel = releaseProject.getModel();
219
220
221
222 releaseModel.setParent( null );
223 releaseModel.setProfiles( Collections.<Profile>emptyList() );
224 releaseModel.setDependencyManagement( null );
225 releaseProject.getBuild().setPluginManagement( null );
226
227
228 String projectVersion = releaseModel.getVersion();
229 String releaseVersion =
230 getNextVersion( releaseDescriptor, project.getGroupId(), project.getArtifactId() );
231 releaseModel.setVersion( releaseVersion );
232
233 String originalFinalName = releaseModel.getBuild().getFinalName();
234
235 if ( !FINALNAME_EXPRESSION.equals( originalFinalName ) )
236 {
237 originalFinalName = findOriginalFinalName( project );
238
239 if ( originalFinalName == null )
240 {
241
242 originalFinalName = FINALNAME_EXPRESSION;
243 }
244 }
245
246
247 String finalName = ReleaseUtil.interpolate( originalFinalName, releaseModel );
248
249
250 if ( finalName.indexOf( Artifact.SNAPSHOT_VERSION ) != -1 )
251 {
252 throw new ReleaseFailureException( "Cannot reliably adjust the finalName of project: "
253 + releaseProject.getId() );
254 }
255 releaseModel.getBuild().setFinalName( finalName );
256
257
258
259 Scm scm = releaseModel.getScm();
260
261 if ( scm != null )
262 {
263 ScmRepository scmRepository = getScmRepository( releaseDescriptor, releaseEnvironment );
264 ScmTranslator scmTranslator = getScmTranslator( scmRepository );
265
266 if ( scmTranslator != null )
267 {
268 releaseModel.setScm( createReleaseScm( releaseModel.getScm(), scmTranslator, releaseDescriptor ) );
269 }
270 else
271 {
272 String message = "No SCM translator found - skipping rewrite";
273
274 result.appendDebug( message );
275
276 getLogger().debug( message );
277 }
278 }
279
280
281 releaseModel.setDependencies( createReleaseDependencies( releaseDescriptor, releaseProject ) );
282
283
284 releaseModel.getBuild().setPlugins( createReleasePlugins( releaseDescriptor, releaseProject ) );
285
286
287 releaseModel.getReporting().setPlugins( createReleaseReportPlugins( releaseDescriptor,
288 releaseProject ) );
289
290
291 releaseModel.getBuild().setExtensions( createReleaseExtensions( releaseDescriptor,
292 releaseProject ) );
293
294 unalignFromBaseDirectory( releaseModel, project.getBasedir() );
295
296 return releaseModel;
297 }
298
299
300 private void unalignFromBaseDirectory( Model releaseModel, File basedir )
301 {
302 Model rawSuperModel = superPomProvider.getSuperModel( releaseModel.getModelVersion() );
303
304 ModelBuildingRequest buildingRequest = new DefaultModelBuildingRequest();
305 buildingRequest.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_STRICT );
306
307
308 Properties properties = new Properties();
309 properties.put( "project.version", releaseModel.getVersion() );
310 properties.put( "project.artifactId", releaseModel.getArtifactId() );
311 buildingRequest.setUserProperties( properties );
312
313 Model interpolatedSuperModel =
314 modelInterpolator.interpolateModel( rawSuperModel.clone(), basedir, buildingRequest, null );
315
316 Build currentBuild = releaseModel.getBuild();
317 Build interpolatedSuperBuild = interpolatedSuperModel.getBuild();
318 Build rawSuperBuild = rawSuperModel.getBuild();
319
320 currentBuild.setSourceDirectory( resolvePath( basedir.toPath(), currentBuild.getSourceDirectory(),
321 interpolatedSuperBuild.getSourceDirectory(),
322 rawSuperBuild.getSourceDirectory() ) );
323 currentBuild.setScriptSourceDirectory( resolvePath( basedir.toPath(), currentBuild.getScriptSourceDirectory(),
324 interpolatedSuperBuild.getScriptSourceDirectory(),
325 rawSuperBuild.getScriptSourceDirectory() ) );
326 currentBuild.setTestSourceDirectory( resolvePath( basedir.toPath(), currentBuild.getTestSourceDirectory(),
327 interpolatedSuperBuild.getTestSourceDirectory(),
328 rawSuperBuild.getTestSourceDirectory() ) );
329 currentBuild.setOutputDirectory( resolvePath( basedir.toPath(), currentBuild.getOutputDirectory(),
330 interpolatedSuperBuild.getOutputDirectory(),
331 rawSuperBuild.getOutputDirectory() ) );
332 currentBuild.setTestOutputDirectory( resolvePath( basedir.toPath(), currentBuild.getTestOutputDirectory(),
333 interpolatedSuperBuild.getTestOutputDirectory(),
334 rawSuperBuild.getTestOutputDirectory() ) );
335 currentBuild.setDirectory( resolvePath( basedir.toPath(), currentBuild.getDirectory(),
336 interpolatedSuperBuild.getDirectory(),
337 rawSuperBuild.getDirectory() ) );
338
339 for ( Resource currentResource : currentBuild.getResources() )
340 {
341 Map<String, String> superResourceDirectories =
342 new LinkedHashMap<>( interpolatedSuperBuild.getResources().size() );
343 for ( int i = 0; i < interpolatedSuperBuild.getResources().size(); i++ )
344 {
345 superResourceDirectories.put( interpolatedSuperBuild.getResources().get( i ).getDirectory(),
346 rawSuperBuild.getResources().get( i ).getDirectory() );
347 }
348 currentResource.setDirectory( resolvePath( basedir.toPath(), currentResource.getDirectory(),
349 superResourceDirectories ) );
350 }
351
352 for ( Resource currentResource : currentBuild.getTestResources() )
353 {
354 Map<String, String> superResourceDirectories =
355 new LinkedHashMap<>( interpolatedSuperBuild.getTestResources().size() );
356 for ( int i = 0; i < interpolatedSuperBuild.getTestResources().size(); i++ )
357 {
358 superResourceDirectories.put( interpolatedSuperBuild.getTestResources().get( i ).getDirectory(),
359 rawSuperBuild.getTestResources().get( i ).getDirectory() );
360 }
361 currentResource.setDirectory( resolvePath( basedir.toPath(), currentResource.getDirectory(),
362 superResourceDirectories ) );
363 }
364
365
366
367 releaseModel.getReporting().setOutputDirectory( resolvePath( basedir.toPath(),
368 releaseModel.getReporting().getOutputDirectory(),
369 interpolatedSuperModel.getReporting().getOutputDirectory(),
370 rawSuperModel.getReporting().getOutputDirectory() ) );
371 }
372
373 private String resolvePath( Path basedir, String current, String superInterpolated, String superRaw )
374 {
375 return basedir.resolve( current ).equals( basedir.resolve( superInterpolated ) ) ? superRaw : current;
376 }
377
378 private String resolvePath( Path basedir,
379 String current,
380 Map<String , String > superValues )
381 {
382 for ( Map.Entry<String, String> superValue : superValues.entrySet() )
383 {
384 if ( basedir.resolve( current ).equals( basedir.resolve( superValue.getKey() ) ) )
385 {
386 return superValue.getValue();
387 }
388 }
389 return current;
390 }
391
392 private String findOriginalFinalName( MavenProject project )
393 {
394 if ( project.getOriginalModel().getBuild() != null
395 && project.getOriginalModel().getBuild().getFinalName() != null )
396 {
397 return project.getOriginalModel().getBuild().getFinalName();
398 }
399 else if ( project.hasParent() )
400 {
401 return findOriginalFinalName( project.getParent() );
402 }
403 else
404 {
405 return null;
406 }
407 }
408
409 @Override
410 public ReleaseResult simulate( ReleaseDescriptor releaseDescriptor, ReleaseEnvironment releaseEnvironment,
411 List<MavenProject> reactorProjects )
412 throws ReleaseExecutionException, ReleaseFailureException
413 {
414 return execute( releaseDescriptor, releaseEnvironment, reactorProjects, true );
415 }
416
417 private String getNextVersion( ReleaseDescriptor releaseDescriptor, String groupId, String artifactId )
418 throws ReleaseFailureException
419 {
420
421
422 String id = ArtifactUtils.versionlessKey( groupId, artifactId );
423
424 String nextVersion = releaseDescriptor.getProjectReleaseVersion( id );
425
426 if ( nextVersion == null )
427 {
428 throw new ReleaseFailureException( "Version for '" + id + "' was not mapped" );
429 }
430
431 return nextVersion;
432 }
433
434 private ScmTranslator getScmTranslator( ScmRepository scmRepository )
435 {
436 return scmTranslators.get( scmRepository.getProvider() );
437 }
438
439 private Scm createReleaseScm( Scm scm, ScmTranslator scmTranslator, ReleaseDescriptor releaseDescriptor )
440 {
441
442
443 String tag = releaseDescriptor.getScmReleaseLabel();
444 String tagBase = releaseDescriptor.getScmTagBase();
445
446 Scm releaseScm = new Scm();
447
448 if ( scm.getConnection() != null )
449 {
450 String value = scmTranslator.translateTagUrl( scm.getConnection(), tag, tagBase );
451 releaseScm.setConnection( value );
452 }
453
454 if ( scm.getDeveloperConnection() != null )
455 {
456 String value = scmTranslator.translateTagUrl( scm.getDeveloperConnection(), tag, tagBase );
457 releaseScm.setDeveloperConnection( value );
458 }
459
460 if ( scm.getUrl() != null )
461 {
462 String value = scmTranslator.translateTagUrl( scm.getUrl(), tag, tagBase );
463 releaseScm.setUrl( value );
464 }
465
466 if ( scm.getTag() != null )
467 {
468 String value = scmTranslator.resolveTag( scm.getTag() );
469 releaseScm.setTag( value );
470 }
471
472 return releaseScm;
473 }
474
475 private List<Dependency> createReleaseDependencies( ReleaseDescriptor releaseDescriptor,
476 MavenProject project )
477 throws ReleaseFailureException
478 {
479 Set<Artifact> artifacts = project.getArtifacts();
480
481 List<Dependency> releaseDependencies = null;
482
483 if ( artifacts != null )
484 {
485
486 List<Artifact> orderedArtifacts = new ArrayList<>();
487 orderedArtifacts.addAll( artifacts );
488 Collections.sort( orderedArtifacts );
489
490 releaseDependencies = new ArrayList<>();
491
492 for ( Artifact artifact : orderedArtifacts )
493 {
494 Dependency releaseDependency = new Dependency();
495
496 releaseDependency.setGroupId( artifact.getGroupId() );
497 releaseDependency.setArtifactId( artifact.getArtifactId() );
498
499 String version = getReleaseVersion( releaseDescriptor, artifact );
500
501 releaseDependency.setVersion( version );
502 releaseDependency.setType( artifact.getType() );
503 releaseDependency.setScope( artifact.getScope() );
504 releaseDependency.setClassifier( artifact.getClassifier() );
505
506 releaseDependencies.add( releaseDependency );
507 }
508 }
509
510 return releaseDependencies;
511 }
512
513 private String getReleaseVersion( ReleaseDescriptor releaseDescriptor,
514 Artifact artifact )
515 throws ReleaseFailureException
516 {
517 String key = ArtifactUtils.versionlessKey( artifact );
518
519 String originalVersion = releaseDescriptor.getProjectOriginalVersion( key );
520 String mappedVersion = releaseDescriptor.getProjectReleaseVersion( key );
521
522 String version = artifact.getVersion();
523
524 if ( version.equals( originalVersion ) )
525 {
526 if ( mappedVersion != null )
527 {
528 version = mappedVersion;
529 }
530 else
531 {
532 throw new ReleaseFailureException( "Version '" + version + "' for '" + key + "' was not mapped" );
533 }
534 }
535 else
536 {
537 if ( !ArtifactUtils.isSnapshot( version ) )
538 {
539 version = artifact.getBaseVersion();
540 }
541 }
542
543 return version;
544 }
545
546 private List<Plugin> createReleasePlugins( ReleaseDescriptor releaseDescriptor,
547 MavenProject project )
548 throws ReleaseFailureException
549 {
550 List<Plugin> releasePlugins = null;
551
552
553 Build build = project.getOriginalModel().getBuild();
554
555 if ( build != null )
556 {
557 List<Plugin> plugins = build.getPlugins();
558
559 if ( plugins != null )
560 {
561 Map<String, Artifact> artifactsById = project.getPluginArtifactMap();
562
563 releasePlugins = new ArrayList<>();
564
565 for ( Plugin plugin : plugins )
566 {
567 String id = ArtifactUtils.versionlessKey( plugin.getGroupId(), plugin.getArtifactId() );
568 Artifact artifact = artifactsById.get( id );
569 String version = getReleaseVersion( releaseDescriptor, artifact );
570
571 Plugin releasePlugin = new Plugin();
572 releasePlugin.setGroupId( plugin.getGroupId() );
573 releasePlugin.setArtifactId( plugin.getArtifactId() );
574 releasePlugin.setVersion( version );
575 if ( plugin.getExtensions() != null )
576 {
577 releasePlugin.setExtensions( plugin.isExtensions() );
578 }
579 releasePlugin.setExecutions( plugin.getExecutions() );
580 releasePlugin.setDependencies( plugin.getDependencies() );
581 releasePlugin.setGoals( plugin.getGoals() );
582 releasePlugin.setInherited( plugin.getInherited() );
583 releasePlugin.setConfiguration( plugin.getConfiguration() );
584
585 releasePlugins.add( releasePlugin );
586 }
587 }
588 }
589
590 return releasePlugins;
591 }
592
593 private List<ReportPlugin> createReleaseReportPlugins( ReleaseDescriptor releaseDescriptor,
594 MavenProject project )
595 throws ReleaseFailureException
596 {
597 List<ReportPlugin> releaseReportPlugins = null;
598
599 Reporting reporting = project.getModel().getReporting();
600
601 if ( reporting != null )
602 {
603 List<ReportPlugin> reportPlugins = reporting.getPlugins();
604
605 if ( reportPlugins != null )
606 {
607 Map<String, Artifact> artifactsById = project.getReportArtifactMap();
608
609 releaseReportPlugins = new ArrayList<>();
610
611 for ( ReportPlugin reportPlugin : reportPlugins )
612 {
613 String id = ArtifactUtils.versionlessKey( reportPlugin.getGroupId(), reportPlugin.getArtifactId() );
614 Artifact artifact = artifactsById.get( id );
615 String version = getReleaseVersion( releaseDescriptor, artifact );
616
617 ReportPlugin releaseReportPlugin = new ReportPlugin();
618 releaseReportPlugin.setGroupId( reportPlugin.getGroupId() );
619 releaseReportPlugin.setArtifactId( reportPlugin.getArtifactId() );
620 releaseReportPlugin.setVersion( version );
621 releaseReportPlugin.setInherited( reportPlugin.getInherited() );
622 releaseReportPlugin.setConfiguration( reportPlugin.getConfiguration() );
623 releaseReportPlugin.setReportSets( reportPlugin.getReportSets() );
624
625 releaseReportPlugins.add( releaseReportPlugin );
626 }
627 }
628 }
629
630 return releaseReportPlugins;
631 }
632
633 private List<Extension> createReleaseExtensions( ReleaseDescriptor releaseDescriptor,
634 MavenProject project )
635 throws ReleaseFailureException
636 {
637 List<Extension> releaseExtensions = null;
638
639
640 Build build = project.getOriginalModel().getBuild();
641
642 if ( build != null )
643 {
644 List<Extension> extensions = build.getExtensions();
645
646 if ( extensions != null )
647 {
648 releaseExtensions = new ArrayList<>();
649
650 for ( Extension extension : extensions )
651 {
652 String id = ArtifactUtils.versionlessKey( extension.getGroupId(), extension.getArtifactId() );
653 Artifact artifact = project.getExtensionArtifactMap().get( id );
654 String version = getReleaseVersion( releaseDescriptor, artifact );
655
656 Extension releaseExtension = new Extension();
657 releaseExtension.setGroupId( extension.getGroupId() );
658 releaseExtension.setArtifactId( extension.getArtifactId() );
659 releaseExtension.setVersion( version );
660
661 releaseExtensions.add( releaseExtension );
662 }
663 }
664 }
665
666 return releaseExtensions;
667 }
668
669
670
671
672 @Override
673 public ReleaseResult clean( List<MavenProject> reactorProjects )
674 {
675 ReleaseResult result = new ReleaseResult();
676
677 for ( MavenProject project : reactorProjects )
678 {
679 File releasePom = ReleaseUtil.getReleasePom( project );
680
681
682 if ( releasePom != null && releasePom.exists() )
683 {
684 logInfo( result, "Deleting release POM for '" + project.getName() + "'..." );
685
686 if ( !releasePom.delete() )
687 {
688 logWarn( result, "Cannot delete release POM: " + releasePom );
689 }
690 }
691 }
692
693 result.setResultCode( ReleaseResult.SUCCESS );
694
695 return result;
696 }
697 }