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