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