source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.converter.artifact;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import java.io.File;
  23 import java.io.FileNotFoundException;
  24 import java.io.FileReader;
  25 import java.io.IOException;
  26 import java.io.StringReader;
  27 import java.io.StringWriter;
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Properties;
  33 import java.util.regex.Matcher;
  34
  35 import org.apache.commons.io.FileUtils;
  36 import org.apache.commons.io.IOUtils;
  37 import org.apache.maven.archiva.transaction.FileTransaction;
  38 import org.apache.maven.archiva.transaction.TransactionException;
  39 import org.apache.maven.artifact.Artifact;
  40 import org.apache.maven.artifact.factory.ArtifactFactory;
  41 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
  42 import org.apache.maven.artifact.repository.ArtifactRepository;
  43 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
  44 import org.apache.maven.artifact.repository.metadata.Metadata;
  45 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  46 import org.apache.maven.artifact.repository.metadata.Snapshot;
  47 import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
  48 import org.apache.maven.artifact.repository.metadata.Versioning;
  49 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
  50 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Writer;
  51 import org.apache.maven.model.DistributionManagement;
  52 import org.apache.maven.model.Model;
  53 import org.apache.maven.model.Relocation;
  54 import org.apache.maven.model.converter.ModelConverter;
  55 import org.apache.maven.model.converter.PomTranslationException;
  56 import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
  57 import org.codehaus.plexus.digest.Digester;
  58 import org.codehaus.plexus.digest.DigesterException;
  59 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  60
  61 /**
  62  * LegacyToDefaultConverter
  63  *
  64  * @version $Id$
  65  *
  66  * @plexus.component role="org.apache.maven.archiva.converter.artifact.ArtifactConverter"
  67  *      role-hint="legacy-to-default"
  68  */
  69 public class LegacyToDefaultConverter
  70     implements ArtifactConverter
  71 {
  72     /**
  73      * {@link List}&lt;{@link Digester}>
  74      *
  75      * @plexus.requirement role="org.codehaus.plexus.digest.Digester"
  76      */
  77     private List<Digester> digesters;
  78
  79     /**
  80      * @plexus.requirement
  81      */
  82     private ModelConverter translator;
  83
  84     /**
  85      * @plexus.requirement
  86      */
  87     private ArtifactFactory artifactFactory;
  88
  89     /**
  90      * @plexus.requirement
  91      */
  92     private ArtifactHandlerManager artifactHandlerManager;
  93
  94     /**
  95      * @plexus.configuration default-value="false"
  96      */
  97     private boolean force;
  98
  99     /**
 100      * @plexus.configuration default-value="false"
 101      */
 102     private boolean dryrun;
 103
 104     private Map<Artifact,List<String>> warnings = new HashMap<Artifact,List<String>>();
 105
 106     public void convert( Artifact artifact, ArtifactRepository targetRepository )
 107         throws ArtifactConversionException
 108     {
 109         if ( artifact.getRepository().getUrl().equals( targetRepository.getUrl() ) )
 110         {
 111             throw new ArtifactConversionException( Messages.getString( "exception.repositories.match" ) ); //$NON-NLS-1$
 112         }
 113
 114         if ( !validateMetadata( artifact ) )
 115         {
 116             addWarning( artifact, Messages.getString( "unable.to.validate.metadata" ) ); //$NON-NLS-1$
 117             return;
 118         }
 119
 120         FileTransaction transaction = new FileTransaction();
 121
 122         if ( !copyPom( artifact, targetRepository, transaction ) )
 123         {
 124             addWarning( artifact, Messages.getString( "unable.to.copy.pom" ) ); //$NON-NLS-1$
 125             return;
 126         }
 127
 128         if ( !copyArtifact( artifact, targetRepository, transaction ) )
 129         {
 130             addWarning( artifact, Messages.getString( "unable.to.copy.artifact" ) ); //$NON-NLS-1$
 131             return;
 132         }
 133
 134         Metadata metadata = createBaseMetadata( artifact );
 135         Versioning versioning = new Versioning();
 136         versioning.addVersion( artifact.getBaseVersion() );
 137         metadata.setVersioning( versioning );
 138         updateMetadata( new ArtifactRepositoryMetadata( artifact ), targetRepository, metadata, transaction );
 139
 140         metadata = createBaseMetadata( artifact );
 141         metadata.setVersion( artifact.getBaseVersion() );
 142         versioning = new Versioning();
 143
 144         Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() );
 145         if ( matcher.matches() )
 146         {
 147             Snapshot snapshot = new Snapshot();
 148             snapshot.setBuildNumber( Integer.valueOf( matcher.group( 3 ) ).intValue() );
 149             snapshot.setTimestamp( matcher.group( 2 ) );
 150             versioning.setSnapshot( snapshot );
 151         }
 152
 153         // TODO: merge latest/release/snapshot from source instead
 154         metadata.setVersioning( versioning );
 155         updateMetadata( new SnapshotArtifactRepositoryMetadata( artifact ), targetRepository, metadata, transaction );
 156
 157         if ( !dryrun )
 158         {
 159             try
 160             {
 161                 transaction.commit();
 162             }
 163             catch ( TransactionException e )
 164             {
 165                 throw new ArtifactConversionException( Messages.getString( "transaction.failure", e.getMessage() ), e ); //$NON-NLS-1$
 166             }
 167         }
 168     }
 169
 170     @SuppressWarnings("unchecked")
 171     private boolean copyPom( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
 172         throws ArtifactConversionException
 173     {
 174         Artifact pom = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact
 175             .getVersion() );
 176         pom.setBaseVersion( artifact.getBaseVersion() );
 177         ArtifactRepository repository = artifact.getRepository();
 178         File file = new File( repository.getBasedir(), repository.pathOf( pom ) );
 179
 180         boolean result = true;
 181         if ( file.exists() )
 182         {
 183             File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( pom ) );
 184
 185             String contents = null;
 186             boolean checksumsValid = false;
 187             try
 188             {
 189                 if ( testChecksums( artifact, file ) )
 190                 {
 191                     checksumsValid = true;
 192                 }
 193
 194                 // Even if the checksums for the POM are invalid we should still convert the POM
 195                 contents = FileUtils.readFileToString( file, null );
 196             }
 197             catch ( IOException e )
 198             {
 199                 throw new ArtifactConversionException(
 200                                                        Messages.getString( "unable.to.read.source.pom", e.getMessage() ), e ); //$NON-NLS-1$
 201             }
 202
 203             if ( checksumsValid && contents.indexOf( "modelVersion" ) >= 0 ) //$NON-NLS-1$
 204             {
 205                 // v4 POM
 206                 try
 207                 {
 208                     boolean matching = false;
 209                     if ( !force && targetFile.exists() )
 210                     {
 211                         String targetContents = FileUtils.readFileToString( targetFile, null );
 212                         matching = targetContents.equals( contents );
 213                     }
 214                     if ( force || !matching )
 215                     {
 216                         transaction.createFile( contents, targetFile, digesters );
 217                     }
 218                 }
 219                 catch ( IOException e )
 220                 {
 221                     throw new ArtifactConversionException( Messages
 222                         .getString( "unable.to.write.target.pom", e.getMessage() ), e ); //$NON-NLS-1$
 223                 }
 224             }
 225             else
 226             {
 227                 // v3 POM
 228                 StringReader stringReader = new StringReader( contents );
 229                 StringWriter writer = null;
 230                 try
 231                 {
 232                     org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader v3Reader = new org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader();
 233                     org.apache.maven.model.v3_0_0.Model v3Model = v3Reader.read( stringReader );
 234
 235                     if ( doRelocation( artifact, v3Model, targetRepository, transaction ) )
 236                     {
 237                         Artifact relocatedPom = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact
 238                             .getArtifactId(), artifact.getVersion() );
 239                         targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( relocatedPom ) );
 240                     }
 241
 242                     Model v4Model = translator.translate( v3Model );
 243
 244                     translator.validateV4Basics( v4Model, v3Model.getGroupId(), v3Model.getArtifactId(), v3Model
 245                         .getVersion(), v3Model.getPackage() );
 246
 247                     writer = new StringWriter();
 248                     MavenXpp3Writer Xpp3Writer = new MavenXpp3Writer();
 249                     Xpp3Writer.write( writer, v4Model );
 250
 251                     transaction.createFile( writer.toString(), targetFile, digesters );
 252
 253                     List<String> warnings = translator.getWarnings();
 254
 255                     for ( String message : warnings )
 256                     {
 257                         addWarning( artifact, message );
 258                     }
 259                 }
 260                 catch ( XmlPullParserException e )
 261                 {
 262                     addWarning( artifact, Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
 263                     result = false;
 264                 }
 265                 catch ( IOException e )
 266                 {
 267                     throw new ArtifactConversionException( Messages.getString( "unable.to.write.converted.pom" ), e ); //$NON-NLS-1$
 268                 }
 269                 catch ( PomTranslationException e )
 270                 {
 271                     addWarning( artifact, Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
 272                     result = false;
 273                 }
 274                 finally
 275                 {
 276                     IOUtils.closeQuietly( writer );
 277                 }
 278             }
 279         }
 280         else
 281         {
 282             addWarning( artifact, Messages.getString( "warning.missing.pom" ) ); //$NON-NLS-1$
 283         }
 284         return result;
 285     }
 286
 287     private boolean testChecksums( Artifact artifact, File file )
 288         throws IOException
 289     {
 290         boolean result = true;
 291         for ( Digester digester : digesters )
 292         {
 293             result &= verifyChecksum( file, file.getName() + "." + getDigesterFileExtension( digester ), digester, //$NON-NLS-1$
 294                                       artifact, "failure.incorrect." + getDigesterFileExtension( digester ) ); //$NON-NLS-1$
 295         }
 296         return result;
 297     }
 298
 299     private boolean verifyChecksum( File file, String fileName, Digester digester, Artifact artifact, String key )
 300         throws IOException
 301     {
 302         boolean result = true;
 303
 304         File checksumFile = new File( file.getParentFile(), fileName );
 305         if ( checksumFile.exists() )
 306         {
 307             String checksum = FileUtils.readFileToString( checksumFile, null );
 308             try
 309             {
 310                 digester.verify( file, checksum );
 311             }
 312             catch ( DigesterException e )
 313             {
 314                 addWarning( artifact, Messages.getString( key ) );
 315                 result = false;
 316             }
 317         }
 318         return result;
 319     }
 320
 321     /**
 322      * File extension for checksums
 323      * TODO should be moved to plexus-digester ?
 324      */
 325     private String getDigesterFileExtension( Digester digester )
 326     {
 327         return digester.getAlgorithm().toLowerCase().replaceAll( "-", "" ); //$NON-NLS-1$ //$NON-NLS-2$
 328     }
 329
 330     private boolean copyArtifact( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
 331         throws ArtifactConversionException
 332     {
 333         File sourceFile = artifact.getFile();
 334
 335         if ( sourceFile.getAbsolutePath().indexOf( "/plugins/" ) > -1 ) //$NON-NLS-1$
 336         {
 337             artifact.setArtifactHandler( artifactHandlerManager.getArtifactHandler( "maven-plugin" ) ); //$NON-NLS-1$
 338         }
 339
 340         File targetFile = new File( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 341
 342         boolean result = true;
 343         try
 344         {
 345             boolean matching = false;
 346             if ( !force && targetFile.exists() )
 347             {
 348                 matching = FileUtils.contentEquals( sourceFile, targetFile );
 349                 if ( !matching )
 350                 {
 351                     addWarning( artifact, Messages.getString( "failure.target.already.exists" ) ); //$NON-NLS-1$
 352                     result = false;
 353                 }
 354             }
 355             if ( result )
 356             {
 357                 if ( force || !matching )
 358                 {
 359                     if ( testChecksums( artifact, sourceFile ) )
 360                     {
 361                         transaction.copyFile( sourceFile, targetFile, digesters );
 362                     }
 363                     else
 364                     {
 365                         result = false;
 366                     }
 367                 }
 368             }
 369         }
 370         catch ( IOException e )
 371         {
 372             throw new ArtifactConversionException( Messages.getString( "error.copying.artifact" ), e ); //$NON-NLS-1$
 373         }
 374         return result;
 375     }
 376
 377     private Metadata createBaseMetadata( Artifact artifact )
 378     {
 379         Metadata metadata = new Metadata();
 380         metadata.setArtifactId( artifact.getArtifactId() );
 381         metadata.setGroupId( artifact.getGroupId() );
 382         return metadata;
 383     }
 384
 385     private Metadata readMetadata( File file )
 386         throws ArtifactConversionException
 387     {
 388         Metadata metadata;
 389         MetadataXpp3Reader reader = new MetadataXpp3Reader();
 390         FileReader fileReader = null;
 391         try
 392         {
 393             fileReader = new FileReader( file );
 394             metadata = reader.read( fileReader );
 395         }
 396         catch ( FileNotFoundException e )
 397         {
 398             throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ), e ); //$NON-NLS-1$
 399         }
 400         catch ( IOException e )
 401         {
 402             throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ), e ); //$NON-NLS-1$
 403         }
 404         catch ( XmlPullParserException e )
 405         {
 406             throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ), e ); //$NON-NLS-1$
 407         }
 408         finally
 409         {
 410             IOUtils.closeQuietly( fileReader );
 411         }
 412         return metadata;
 413     }
 414
 415     private boolean validateMetadata( Artifact artifact )
 416         throws ArtifactConversionException
 417     {
 418         ArtifactRepository repository = artifact.getRepository();
 419
 420         boolean result = true;
 421
 422         RepositoryMetadata repositoryMetadata = new ArtifactRepositoryMetadata( artifact );
 423         File file = new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
 424         if ( file.exists() )
 425         {
 426             Metadata metadata = readMetadata( file );
 427             result = validateMetadata( metadata, repositoryMetadata, artifact );
 428         }
 429
 430         repositoryMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 431         file = new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
 432         if ( file.exists() )
 433         {
 434             Metadata metadata = readMetadata( file );
 435             result = result && validateMetadata( metadata, repositoryMetadata, artifact );
 436         }
 437
 438         return result;
 439     }
 440
 441     @SuppressWarnings("unchecked")
 442     private boolean validateMetadata( Metadata metadata, RepositoryMetadata repositoryMetadata, Artifact artifact )
 443     {
 444         String groupIdKey;
 445         String artifactIdKey = null;
 446         String snapshotKey = null;
 447         String versionKey = null;
 448         String versionsKey = null;
 449
 450         if ( repositoryMetadata.storedInGroupDirectory() )
 451         {
 452             groupIdKey = "failure.incorrect.groupMetadata.groupId"; //$NON-NLS-1$
 453         }
 454         else if ( repositoryMetadata.storedInArtifactVersionDirectory() )
 455         {
 456             groupIdKey = "failure.incorrect.snapshotMetadata.groupId"; //$NON-NLS-1$
 457             artifactIdKey = "failure.incorrect.snapshotMetadata.artifactId"; //$NON-NLS-1$
 458             versionKey = "failure.incorrect.snapshotMetadata.version"; //$NON-NLS-1$
 459             snapshotKey = "failure.incorrect.snapshotMetadata.snapshot"; //$NON-NLS-1$
 460         }
 461         else
 462         {
 463             groupIdKey = "failure.incorrect.artifactMetadata.groupId"; //$NON-NLS-1$
 464             artifactIdKey = "failure.incorrect.artifactMetadata.artifactId"; //$NON-NLS-1$
 465             versionsKey = "failure.incorrect.artifactMetadata.versions"; //$NON-NLS-1$
 466         }
 467
 468         boolean result = true;
 469
 470         if ( metadata.getGroupId() == null || !metadata.getGroupId().equals( artifact.getGroupId() ) )
 471         {
 472             addWarning( artifact, Messages.getString( groupIdKey ) );
 473             result = false;
 474         }
 475         if ( !repositoryMetadata.storedInGroupDirectory() )
 476         {
 477             if ( metadata.getGroupId() == null || !metadata.getArtifactId().equals( artifact.getArtifactId() ) )
 478             {
 479                 addWarning( artifact, Messages.getString( artifactIdKey ) );
 480                 result = false;
 481             }
 482             if ( !repositoryMetadata.storedInArtifactVersionDirectory() )
 483             {
 484                 // artifact metadata
 485
 486                 boolean foundVersion = false;
 487                 if ( metadata.getVersioning() != null )
 488                 {
 489                     for ( String version : (List<String>) metadata.getVersioning().getVersions() )
 490                     {
 491                         if ( version.equals( artifact.getBaseVersion() ) )
 492                         {
 493                             foundVersion = true;
 494                             break;
 495                         }
 496                     }
 497                 }
 498
 499                 if ( !foundVersion )
 500                 {
 501                     addWarning( artifact, Messages.getString( versionsKey ) );
 502                     result = false;
 503                 }
 504             }
 505             else
 506             {
 507                 // snapshot metadata
 508                 if ( !artifact.getBaseVersion().equals( metadata.getVersion() ) )
 509                 {
 510                     addWarning( artifact, Messages.getString( versionKey ) );
 511                     result = false;
 512                 }
 513
 514                 if ( artifact.isSnapshot() )
 515                 {
 516                     Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() );
 517                     if ( matcher.matches() )
 518                     {
 519                         boolean correct = false;
 520                         if ( metadata.getVersioning() != null && metadata.getVersioning().getSnapshot() != null )
 521                         {
 522                             Snapshot snapshot = metadata.getVersioning().getSnapshot();
 523                             int build = Integer.valueOf( matcher.group( 3 ) ).intValue();
 524                             String ts = matcher.group( 2 );
 525                             if ( build == snapshot.getBuildNumber() && ts.equals( snapshot.getTimestamp() ) )
 526                             {
 527                                 correct = true;
 528                             }
 529                         }
 530
 531                         if ( !correct )
 532                         {
 533                             addWarning( artifact, Messages.getString( snapshotKey ) );
 534                             result = false;
 535                         }
 536                     }
 537                 }
 538             }
 539         }
 540         return result;
 541     }
 542
 543     private void updateMetadata( RepositoryMetadata artifactMetadata, ArtifactRepository targetRepository,
 544                                  Metadata newMetadata, FileTransaction transaction )
 545         throws ArtifactConversionException
 546     {
 547         File file = new File( targetRepository.getBasedir(), targetRepository
 548             .pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 549
 550         Metadata metadata;
 551         boolean changed;
 552
 553         if ( file.exists() )
 554         {
 555             metadata = readMetadata( file );
 556             changed = metadata.merge( newMetadata );
 557         }
 558         else
 559         {
 560             changed = true;
 561             metadata = newMetadata;
 562         }
 563
 564         if ( changed )
 565         {
 566             StringWriter writer = null;
 567             try
 568             {
 569                 writer = new StringWriter();
 570
 571                 MetadataXpp3Writer mappingWriter = new MetadataXpp3Writer();
 572
 573                 mappingWriter.write( writer, metadata );
 574
 575                 transaction.createFile( writer.toString(), file, digesters );
 576             }
 577             catch ( IOException e )
 578             {
 579                 throw new ArtifactConversionException( Messages.getString( "error.writing.target.metadata" ), e ); //$NON-NLS-1$
 580             }
 581             finally
 582             {
 583                 IOUtils.closeQuietly( writer );
 584             }
 585         }
 586     }
 587
 588     private boolean doRelocation( Artifact artifact, org.apache.maven.model.v3_0_0.Model v3Model,
 589                                   ArtifactRepository repository, FileTransaction transaction )
 590         throws IOException
 591     {
 592         Properties properties = v3Model.getProperties();
 593         if ( properties.containsKey( "relocated.groupId" ) || properties.containsKey( "relocated.artifactId" ) //$NON-NLS-1$ //$NON-NLS-2$
 594             || properties.containsKey( "relocated.version" ) ) //$NON-NLS-1$
 595         {
 596             String newGroupId = properties.getProperty( "relocated.groupId", v3Model.getGroupId() ); //$NON-NLS-1$
 597             properties.remove( "relocated.groupId" ); //$NON-NLS-1$
 598
 599             String newArtifactId = properties.getProperty( "relocated.artifactId", v3Model.getArtifactId() ); //$NON-NLS-1$
 600             properties.remove( "relocated.artifactId" ); //$NON-NLS-1$
 601
 602             String newVersion = properties.getProperty( "relocated.version", v3Model.getVersion() ); //$NON-NLS-1$
 603             properties.remove( "relocated.version" ); //$NON-NLS-1$
 604
 605             String message = properties.getProperty( "relocated.message", "" ); //$NON-NLS-1$ //$NON-NLS-2$
 606             properties.remove( "relocated.message" ); //$NON-NLS-1$
 607
 608             if ( properties.isEmpty() )
 609             {
 610                 v3Model.setProperties( null );
 611             }
 612
 613             writeRelocationPom( v3Model.getGroupId(), v3Model.getArtifactId(), v3Model.getVersion(), newGroupId,
 614                                 newArtifactId, newVersion, message, repository, transaction );
 615
 616             v3Model.setGroupId( newGroupId );
 617             v3Model.setArtifactId( newArtifactId );
 618             v3Model.setVersion( newVersion );
 619
 620             artifact.setGroupId( newGroupId );
 621             artifact.setArtifactId( newArtifactId );
 622             artifact.setVersion( newVersion );
 623
 624             return true;
 625         }
 626         else
 627         {
 628             return false;
 629         }
 630     }
 631
 632     private void writeRelocationPom( String groupId, String artifactId, String version, String newGroupId,
 633                                      String newArtifactId, String newVersion, String message,
 634                                      ArtifactRepository repository, FileTransaction transaction )
 635         throws IOException
 636     {
 637         Model pom = new Model();
 638         pom.setGroupId( groupId );
 639         pom.setArtifactId( artifactId );
 640         pom.setVersion( version );
 641
 642         DistributionManagement dMngt = new DistributionManagement();
 643
 644         Relocation relocation = new Relocation();
 645         relocation.setGroupId( newGroupId );
 646         relocation.setArtifactId( newArtifactId );
 647         relocation.setVersion( newVersion );
 648         if ( message != null && message.length() > 0 )
 649         {
 650             relocation.setMessage( message );
 651         }
 652
 653         dMngt.setRelocation( relocation );
 654
 655         pom.setDistributionManagement( dMngt );
 656
 657         Artifact artifact = artifactFactory.createBuildArtifact( groupId, artifactId, version, "pom" ); //$NON-NLS-1$
 658         File pomFile = new File( repository.getBasedir(), repository.pathOf( artifact ) );
 659
 660         StringWriter strWriter = new StringWriter();
 661         MavenXpp3Writer pomWriter = new MavenXpp3Writer();
 662         pomWriter.write( strWriter, pom );
 663
 664         transaction.createFile( strWriter.toString(), pomFile, digesters );
 665     }
 666
 667     private void addWarning( Artifact artifact, String message )
 668     {
 669         List<String> messages = warnings.get( artifact );
 670         if ( messages == null )
 671         {
 672             messages = new ArrayList<String>();
 673         }
 674         messages.add( message );
 675         warnings.put( artifact, messages );
 676     }
 677
 678     public void clearWarnings()
 679     {
 680         warnings.clear();
 681     }
 682
 683     public Map<Artifact, List<String>> getWarnings()
 684     {
 685         return warnings;
 686     }
 687 }