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

   1 package org.apache.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.archiva.checksum.ChecksumAlgorithm;
  23 import org.apache.archiva.checksum.ChecksumValidationException;
  24 import org.apache.archiva.checksum.ChecksummedFile;
  25 import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
  26 import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
  27 import org.apache.archiva.transaction.FileTransaction;
  28 import org.apache.archiva.transaction.TransactionException;
  29 import org.apache.commons.io.FileUtils;
  30 import org.apache.maven.artifact.Artifact;
  31 import org.apache.maven.artifact.factory.ArtifactFactory;
  32 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;
  33 import org.apache.maven.artifact.repository.ArtifactRepository;
  34 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
  35 import org.apache.maven.artifact.repository.metadata.Metadata;
  36 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  37 import org.apache.maven.artifact.repository.metadata.Snapshot;
  38 import org.apache.maven.artifact.repository.metadata.Versioning;
  39 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
  40 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Writer;
  41 import org.apache.maven.model.DistributionManagement;
  42 import org.apache.maven.model.Model;
  43 import org.apache.maven.model.Relocation;
  44 import org.apache.maven.model.converter.ModelConverter;
  45 import org.apache.maven.model.converter.PomTranslationException;
  46 import org.apache.maven.model.io.xpp3.MavenXpp3Writer;
  47 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  48 import org.springframework.stereotype.Service;
  49
  50 import javax.annotation.PostConstruct;
  51 import javax.inject.Inject;
  52 import java.io.IOException;
  53 import java.io.Reader;
  54 import java.io.StringReader;
  55 import java.io.StringWriter;
  56 import java.nio.charset.Charset;
  57 import java.nio.file.Files;
  58 import java.nio.file.Path;
  59 import java.nio.file.Paths;
  60 import java.util.ArrayList;
  61 import java.util.Arrays;
  62 import java.util.HashMap;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.Properties;
  66 import java.util.regex.Matcher;
  67
  68 /**
  69  * LegacyToDefaultConverter
  70  */
  71 @Service("artifactConverter#legacy-to-default")
  72 public class LegacyToDefaultConverter
  73     implements ArtifactConverter
  74 {
  75     /**
  76      *
  77      */
  78     private List<ChecksumAlgorithm> digesters;
  79
  80     @Inject
  81     private PlexusSisuBridge plexusSisuBridge;
  82
  83     private ModelConverter translator;
  84
  85     private ArtifactFactory artifactFactory;
  86
  87     private ArtifactHandlerManager artifactHandlerManager;
  88
  89     private boolean force;
  90
  91     private boolean dryrun;
  92
  93     private Map<Artifact, List<String>> warnings = new HashMap<>();
  94
  95     @PostConstruct
  96     public void initialize()
  97         throws PlexusSisuBridgeException
  98     {
  99         // TODO: Should be configurable!
 100         this.digesters = Arrays.asList(ChecksumAlgorithm.SHA256, ChecksumAlgorithm.SHA1, ChecksumAlgorithm.MD5);
 101         translator = plexusSisuBridge.lookup( ModelConverter.class );
 102         artifactFactory = plexusSisuBridge.lookup( ArtifactFactory.class );
 103         artifactHandlerManager = plexusSisuBridge.lookup( ArtifactHandlerManager.class );
 104     }
 105
 106     @Override
 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.parseInt( matcher.group( 3 ) ) );
 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() ),
 167                                                        e ); //$NON-NLS-1$
 168             }
 169         }
 170     }
 171
 172     @SuppressWarnings("unchecked")
 173     private boolean copyPom( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
 174         throws ArtifactConversionException
 175     {
 176         Artifact pom = artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
 177                                                               artifact.getVersion() );
 178         pom.setBaseVersion( artifact.getBaseVersion() );
 179         ArtifactRepository repository = artifact.getRepository();
 180         Path file = Paths.get( repository.getBasedir(), repository.pathOf( pom ) );
 181
 182         boolean result = true;
 183         if ( Files.exists(file) )
 184         {
 185             Path targetFile = Paths.get( targetRepository.getBasedir(), targetRepository.pathOf( pom ) );
 186
 187             String contents = null;
 188             boolean checksumsValid = false;
 189             try
 190             {
 191                 if ( testChecksums( artifact, file ) )
 192                 {
 193                     checksumsValid = true;
 194                 }
 195
 196                 // Even if the checksums for the POM are invalid we should still convert the POM
 197                 contents = org.apache.archiva.common.utils.FileUtils.readFileToString( file, Charset.defaultCharset() );
 198             }
 199             catch ( IOException e )
 200             {
 201                 throw new ArtifactConversionException(
 202                     Messages.getString( "unable.to.read.source.pom", e.getMessage() ), e ); //$NON-NLS-1$
 203             }
 204
 205             if ( checksumsValid && contents.indexOf( "modelVersion" ) >= 0 ) //$NON-NLS-1$
 206             {
 207                 // v4 POM
 208                 boolean matching = false;
 209                 if ( !force && Files.exists( targetFile ) )
 210                 {
 211                     String targetContents = org.apache.archiva.common.utils.FileUtils.readFileToString( targetFile, Charset.defaultCharset( ) );
 212                     matching = targetContents.equals( contents );
 213                 }
 214                 if ( force || !matching )
 215                 {
 216                     transaction.createFile( contents, targetFile, digesters );
 217                 }
 218             }
 219             else
 220             {
 221                 // v3 POM
 222                 try (StringReader stringReader = new StringReader( contents ))
 223                 {
 224
 225                     try (StringWriter writer = new StringWriter())
 226                     {
 227                         org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader v3Reader =
 228                             new org.apache.maven.model.v3_0_0.io.xpp3.MavenXpp3Reader();
 229                         org.apache.maven.model.v3_0_0.Model v3Model = v3Reader.read( stringReader );
 230
 231                         if ( doRelocation( artifact, v3Model, targetRepository, transaction ) )
 232                         {
 233                             Artifact relocatedPom =
 234                                 artifactFactory.createProjectArtifact( artifact.getGroupId(), artifact.getArtifactId(),
 235                                                                        artifact.getVersion() );
 236                             targetFile =
 237                                 Paths.get( targetRepository.getBasedir(), targetRepository.pathOf( relocatedPom ) );
 238                         }
 239
 240                         Model v4Model = translator.translate( v3Model );
 241
 242                         translator.validateV4Basics( v4Model, v3Model.getGroupId(), v3Model.getArtifactId(),
 243                                                      v3Model.getVersion(), v3Model.getPackage() );
 244
 245                         MavenXpp3Writer xpp3Writer = new MavenXpp3Writer();
 246                         xpp3Writer.write( writer, v4Model );
 247
 248                         transaction.createFile( writer.toString(), targetFile, digesters );
 249
 250                         List<String> warnings = translator.getWarnings();
 251
 252                         for ( String message : warnings )
 253                         {
 254                             addWarning( artifact, message );
 255                         }
 256                     }
 257                     catch ( XmlPullParserException e )
 258                     {
 259                         addWarning( artifact,
 260                                     Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
 261                         result = false;
 262                     }
 263                     catch ( IOException e )
 264                     {
 265                         throw new ArtifactConversionException( Messages.getString( "unable.to.write.converted.pom" ),
 266                                                                e ); //$NON-NLS-1$
 267                     }
 268                     catch ( PomTranslationException e )
 269                     {
 270                         addWarning( artifact,
 271                                     Messages.getString( "invalid.source.pom", e.getMessage() ) ); //$NON-NLS-1$
 272                         result = false;
 273                     }
 274                 }
 275             }
 276         }
 277         else
 278         {
 279             addWarning( artifact, Messages.getString( "warning.missing.pom" ) ); //$NON-NLS-1$
 280         }
 281         return result;
 282     }
 283
 284     private boolean testChecksums( Artifact artifact, Path file )
 285         throws IOException
 286     {
 287         boolean result = true;
 288         for ( ChecksumAlgorithm digester : digesters )
 289         {
 290             result &= verifyChecksum( file, file.getFileName() + "." + getDigesterFileExtension( digester ), digester,
 291                                       //$NON-NLS-1$
 292                                       artifact,
 293                                       "failure.incorrect." + getDigesterFileExtension( digester ) ); //$NON-NLS-1$
 294         }
 295         return result;
 296     }
 297
 298     private boolean verifyChecksum( Path file, String fileName, ChecksumAlgorithm digester, Artifact artifact, String key )
 299         throws IOException
 300     {
 301         boolean result;
 302         Path checksumFile = file.resolveSibling( fileName );
 303         // We ignore the check, if the checksum file does not exist
 304         if (!Files.exists(checksumFile)) {
 305             return true;
 306         }
 307         ChecksummedFile csFile = new ChecksummedFile( file );
 308         try
 309         {
 310             result = csFile.isValidChecksum( digester, true );
 311         } catch (ChecksumValidationException e ) {
 312             addWarning( artifact, Messages.getString( key ) );
 313             result = false;
 314         }
 315         return result;
 316     }
 317
 318     /**
 319      * File extension for checksums
 320      * TODO should be moved to plexus-digester ?
 321      */
 322     private String getDigesterFileExtension( ChecksumAlgorithm checksumAlgorithm )
 323     {
 324         return checksumAlgorithm.getExt().get(0);
 325     }
 326
 327     private boolean copyArtifact( Artifact artifact, ArtifactRepository targetRepository, FileTransaction transaction )
 328         throws ArtifactConversionException
 329     {
 330         Path sourceFile = artifact.getFile().toPath();
 331
 332         if ( sourceFile.toAbsolutePath().toString().indexOf( "/plugins/" ) > -1 ) //$NON-NLS-1$
 333         {
 334             artifact.setArtifactHandler( artifactHandlerManager.getArtifactHandler( "maven-plugin" ) ); //$NON-NLS-1$
 335         }
 336
 337         Path targetFile = Paths.get( targetRepository.getBasedir(), targetRepository.pathOf( artifact ) );
 338
 339         boolean result = true;
 340         try
 341         {
 342             boolean matching = false;
 343             if ( !force && Files.exists(targetFile) )
 344             {
 345                 matching = FileUtils.contentEquals( sourceFile.toFile(), targetFile.toFile() );
 346                 if ( !matching )
 347                 {
 348                     addWarning( artifact, Messages.getString( "failure.target.already.exists" ) ); //$NON-NLS-1$
 349                     result = false;
 350                 }
 351             }
 352             if ( result )
 353             {
 354                 if ( force || !matching )
 355                 {
 356                     if ( testChecksums( artifact, sourceFile ) )
 357                     {
 358                         transaction.copyFile( sourceFile, targetFile, digesters );
 359                     }
 360                     else
 361                     {
 362                         result = false;
 363                     }
 364                 }
 365             }
 366         }
 367         catch ( IOException e )
 368         {
 369             throw new ArtifactConversionException( Messages.getString( "error.copying.artifact" ), e ); //$NON-NLS-1$
 370         }
 371         return result;
 372     }
 373
 374     private Metadata createBaseMetadata( Artifact artifact )
 375     {
 376         Metadata metadata = new Metadata();
 377         metadata.setArtifactId( artifact.getArtifactId() );
 378         metadata.setGroupId( artifact.getGroupId() );
 379         return metadata;
 380     }
 381
 382     private Metadata readMetadata( Path file )
 383         throws ArtifactConversionException
 384     {
 385         MetadataXpp3Reader reader = new MetadataXpp3Reader();
 386
 387         try (Reader fileReader = Files.newBufferedReader( file, Charset.defaultCharset() ))
 388         {
 389             return reader.read( fileReader );
 390         }
 391         catch ( IOException | XmlPullParserException e )
 392         {
 393             throw new ArtifactConversionException( Messages.getString( "error.reading.target.metadata" ),
 394                                                    e ); //$NON-NLS-1$
 395         }
 396     }
 397
 398     private boolean validateMetadata( Artifact artifact )
 399         throws ArtifactConversionException
 400     {
 401         ArtifactRepository repository = artifact.getRepository();
 402
 403         boolean result = true;
 404
 405         RepositoryMetadata repositoryMetadata = new ArtifactRepositoryMetadata( artifact );
 406         Path file = Paths.get( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
 407         if ( Files.exists(file) )
 408         {
 409             Metadata metadata = readMetadata( file );
 410             result = validateMetadata( metadata, repositoryMetadata, artifact );
 411         }
 412
 413         repositoryMetadata = new SnapshotArtifactRepositoryMetadata( artifact );
 414         file = Paths.get( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( repositoryMetadata ) );
 415         if ( Files.exists(file) )
 416         {
 417             Metadata metadata = readMetadata( file );
 418             result = result && validateMetadata( metadata, repositoryMetadata, artifact );
 419         }
 420
 421         return result;
 422     }
 423
 424     @SuppressWarnings("unchecked")
 425     private boolean validateMetadata( Metadata metadata, RepositoryMetadata repositoryMetadata, Artifact artifact )
 426     {
 427         String groupIdKey;
 428         String artifactIdKey = null;
 429         String snapshotKey = null;
 430         String versionKey = null;
 431         String versionsKey = null;
 432
 433         if ( repositoryMetadata.storedInGroupDirectory() )
 434         {
 435             groupIdKey = "failure.incorrect.groupMetadata.groupId"; //$NON-NLS-1$
 436         }
 437         else if ( repositoryMetadata.storedInArtifactVersionDirectory() )
 438         {
 439             groupIdKey = "failure.incorrect.snapshotMetadata.groupId"; //$NON-NLS-1$
 440             artifactIdKey = "failure.incorrect.snapshotMetadata.artifactId"; //$NON-NLS-1$
 441             versionKey = "failure.incorrect.snapshotMetadata.version"; //$NON-NLS-1$
 442             snapshotKey = "failure.incorrect.snapshotMetadata.snapshot"; //$NON-NLS-1$
 443         }
 444         else
 445         {
 446             groupIdKey = "failure.incorrect.artifactMetadata.groupId"; //$NON-NLS-1$
 447             artifactIdKey = "failure.incorrect.artifactMetadata.artifactId"; //$NON-NLS-1$
 448             versionsKey = "failure.incorrect.artifactMetadata.versions"; //$NON-NLS-1$
 449         }
 450
 451         boolean result = true;
 452
 453         if ( metadata.getGroupId() == null || !metadata.getGroupId().equals( artifact.getGroupId() ) )
 454         {
 455             addWarning( artifact, Messages.getString( groupIdKey ) );
 456             result = false;
 457         }
 458         if ( !repositoryMetadata.storedInGroupDirectory() )
 459         {
 460             if ( metadata.getGroupId() == null || !metadata.getArtifactId().equals( artifact.getArtifactId() ) )
 461             {
 462                 addWarning( artifact, Messages.getString( artifactIdKey ) );
 463                 result = false;
 464             }
 465             if ( !repositoryMetadata.storedInArtifactVersionDirectory() )
 466             {
 467                 // artifact metadata
 468
 469                 boolean foundVersion = false;
 470                 if ( metadata.getVersioning() != null )
 471                 {
 472                     for ( String version : (List<String>) metadata.getVersioning().getVersions() )
 473                     {
 474                         if ( version.equals( artifact.getBaseVersion() ) )
 475                         {
 476                             foundVersion = true;
 477                             break;
 478                         }
 479                     }
 480                 }
 481
 482                 if ( !foundVersion )
 483                 {
 484                     addWarning( artifact, Messages.getString( versionsKey ) );
 485                     result = false;
 486                 }
 487             }
 488             else
 489             {
 490                 // snapshot metadata
 491                 if ( !artifact.getBaseVersion().equals( metadata.getVersion() ) )
 492                 {
 493                     addWarning( artifact, Messages.getString( versionKey ) );
 494                     result = false;
 495                 }
 496
 497                 if ( artifact.isSnapshot() )
 498                 {
 499                     Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher( artifact.getVersion() );
 500                     if ( matcher.matches() )
 501                     {
 502                         boolean correct = false;
 503                         if ( metadata.getVersioning() != null && metadata.getVersioning().getSnapshot() != null )
 504                         {
 505                             Snapshot snapshot = metadata.getVersioning().getSnapshot();
 506                             int build = Integer.parseInt( matcher.group( 3 ) );
 507                             String ts = matcher.group( 2 );
 508                             if ( build == snapshot.getBuildNumber() && ts.equals( snapshot.getTimestamp() ) )
 509                             {
 510                                 correct = true;
 511                             }
 512                         }
 513
 514                         if ( !correct )
 515                         {
 516                             addWarning( artifact, Messages.getString( snapshotKey ) );
 517                             result = false;
 518                         }
 519                     }
 520                 }
 521             }
 522         }
 523         return result;
 524     }
 525
 526     private void updateMetadata( RepositoryMetadata artifactMetadata, ArtifactRepository targetRepository,
 527                                  Metadata newMetadata, FileTransaction transaction )
 528         throws ArtifactConversionException
 529     {
 530         Path file = Paths.get( targetRepository.getBasedir(),
 531                               targetRepository.pathOfRemoteRepositoryMetadata( artifactMetadata ) );
 532
 533         Metadata metadata;
 534         boolean changed;
 535
 536         if ( Files.exists(file) )
 537         {
 538             metadata = readMetadata( file );
 539             changed = metadata.merge( newMetadata );
 540         }
 541         else
 542         {
 543             changed = true;
 544             metadata = newMetadata;
 545         }
 546
 547         if ( changed )
 548         {
 549
 550             try (StringWriter writer = new StringWriter())
 551             {
 552                 MetadataXpp3Writer mappingWriter = new MetadataXpp3Writer();
 553
 554                 mappingWriter.write( writer, metadata );
 555
 556                 transaction.createFile( writer.toString(), file, digesters );
 557             }
 558             catch ( IOException e )
 559             {
 560                 throw new ArtifactConversionException( Messages.getString( "error.writing.target.metadata" ),
 561                                                        e ); //$NON-NLS-1$
 562             }
 563         }
 564     }
 565
 566     private boolean doRelocation( Artifact artifact, org.apache.maven.model.v3_0_0.Model v3Model,
 567                                   ArtifactRepository repository, FileTransaction transaction )
 568         throws IOException
 569     {
 570         Properties properties = v3Model.getProperties();
 571         if ( properties.containsKey( "relocated.groupId" ) || properties.containsKey( "relocated.artifactId" )
 572             //$NON-NLS-1$ //$NON-NLS-2$
 573             || properties.containsKey( "relocated.version" ) ) //$NON-NLS-1$
 574         {
 575             String newGroupId = properties.getProperty( "relocated.groupId", v3Model.getGroupId() ); //$NON-NLS-1$
 576             properties.remove( "relocated.groupId" ); //$NON-NLS-1$
 577
 578             String newArtifactId =
 579                 properties.getProperty( "relocated.artifactId", v3Model.getArtifactId() ); //$NON-NLS-1$
 580             properties.remove( "relocated.artifactId" ); //$NON-NLS-1$
 581
 582             String newVersion = properties.getProperty( "relocated.version", v3Model.getVersion() ); //$NON-NLS-1$
 583             properties.remove( "relocated.version" ); //$NON-NLS-1$
 584
 585             String message = properties.getProperty( "relocated.message", "" ); //$NON-NLS-1$ //$NON-NLS-2$
 586             properties.remove( "relocated.message" ); //$NON-NLS-1$
 587
 588             if ( properties.isEmpty() )
 589             {
 590                 v3Model.setProperties( null );
 591             }
 592
 593             writeRelocationPom( v3Model.getGroupId(), v3Model.getArtifactId(), v3Model.getVersion(), newGroupId,
 594                                 newArtifactId, newVersion, message, repository, transaction );
 595
 596             v3Model.setGroupId( newGroupId );
 597             v3Model.setArtifactId( newArtifactId );
 598             v3Model.setVersion( newVersion );
 599
 600             artifact.setGroupId( newGroupId );
 601             artifact.setArtifactId( newArtifactId );
 602             artifact.setVersion( newVersion );
 603
 604             return true;
 605         }
 606         else
 607         {
 608             return false;
 609         }
 610     }
 611
 612     private void writeRelocationPom( String groupId, String artifactId, String version, String newGroupId,
 613                                      String newArtifactId, String newVersion, String message,
 614                                      ArtifactRepository repository, FileTransaction transaction )
 615         throws IOException
 616     {
 617         Model pom = new Model();
 618         pom.setGroupId( groupId );
 619         pom.setArtifactId( artifactId );
 620         pom.setVersion( version );
 621
 622         DistributionManagement dMngt = new DistributionManagement();
 623
 624         Relocation relocation = new Relocation();
 625         relocation.setGroupId( newGroupId );
 626         relocation.setArtifactId( newArtifactId );
 627         relocation.setVersion( newVersion );
 628         if ( message != null && message.length() > 0 )
 629         {
 630             relocation.setMessage( message );
 631         }
 632
 633         dMngt.setRelocation( relocation );
 634
 635         pom.setDistributionManagement( dMngt );
 636
 637         Artifact artifact = artifactFactory.createBuildArtifact( groupId, artifactId, version, "pom" ); //$NON-NLS-1$
 638         Path pomFile = Paths.get( repository.getBasedir(), repository.pathOf( artifact ) );
 639
 640         StringWriter strWriter = new StringWriter();
 641         MavenXpp3Writer pomWriter = new MavenXpp3Writer();
 642         pomWriter.write( strWriter, pom );
 643
 644         transaction.createFile( strWriter.toString(), pomFile, digesters );
 645     }
 646
 647     private void addWarning( Artifact artifact, String message )
 648     {
 649         List<String> messages = warnings.get( artifact );
 650         if ( messages == null )
 651         {
 652             messages = new ArrayList<>( 1 );
 653         }
 654         messages.add( message );
 655         warnings.put( artifact, messages );
 656     }
 657
 658     @Override
 659     public void clearWarnings()
 660     {
 661         warnings.clear();
 662     }
 663
 664     @Override
 665     public Map<Artifact, List<String>> getWarnings()
 666     {
 667         return warnings;
 668     }
 669
 670
 671     public List<ChecksumAlgorithm> getDigesters()
 672     {
 673         return digesters;
 674     }
 675
 676     public void setDigesters( List<ChecksumAlgorithm> digesters )
 677     {
 678         this.digesters = digesters;
 679     }
 680
 681     public ModelConverter getTranslator()
 682     {
 683         return translator;
 684     }
 685
 686     public void setTranslator( ModelConverter translator )
 687     {
 688         this.translator = translator;
 689     }
 690
 691     public ArtifactFactory getArtifactFactory()
 692     {
 693         return artifactFactory;
 694     }
 695
 696     public void setArtifactFactory( ArtifactFactory artifactFactory )
 697     {
 698         this.artifactFactory = artifactFactory;
 699     }
 700
 701     public ArtifactHandlerManager getArtifactHandlerManager()
 702     {
 703         return artifactHandlerManager;
 704     }
 705
 706     public void setArtifactHandlerManager( ArtifactHandlerManager artifactHandlerManager )
 707     {
 708         this.artifactHandlerManager = artifactHandlerManager;
 709     }
 710
 711     public boolean isForce()
 712     {
 713         return force;
 714     }
 715
 716     public void setForce( boolean force )
 717     {
 718         this.force = force;
 719     }
 720
 721     public boolean isDryrun()
 722     {
 723         return dryrun;
 724     }
 725
 726     public void setDryrun( boolean dryrun )
 727     {
 728         this.dryrun = dryrun;
 729     }
 730 }