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

   1 package org.apache.archiva.repository.scanner.mock;
   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.common.filelock.DefaultFileLockManager;
  23 import org.apache.archiva.common.utils.VersionUtil;
  24 import org.apache.archiva.metadata.model.ArtifactMetadata;
  25 import org.apache.archiva.metadata.maven.model.MavenArtifactFacet;
  26 import org.apache.archiva.model.ArchivaArtifact;
  27 import org.apache.archiva.model.ArtifactReference;
  28 import org.apache.archiva.model.ProjectReference;
  29 import org.apache.archiva.model.VersionedReference;
  30 import org.apache.archiva.repository.*;
  31 import org.apache.archiva.repository.content.Artifact;
  32 import org.apache.archiva.repository.content.ContentItem;
  33 import org.apache.archiva.repository.content.ItemNotFoundException;
  34 import org.apache.archiva.repository.content.ItemSelector;
  35 import org.apache.archiva.repository.content.Namespace;
  36 import org.apache.archiva.repository.content.Project;
  37 import org.apache.archiva.repository.content.Version;
  38 import org.apache.archiva.repository.storage.fs.FilesystemStorage;
  39 import org.apache.archiva.repository.storage.StorageAsset;
  40 import org.apache.commons.lang3.StringUtils;
  41
  42 import java.io.IOException;
  43 import java.nio.file.Path;
  44 import java.nio.file.Paths;
  45 import java.util.HashMap;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Set;
  49 import java.util.regex.Matcher;
  50 import java.util.regex.Pattern;
  51 import java.util.stream.Stream;
  52
  53 /**
  54  * @author Martin Stockhammer <martin_s@apache.org>
  55  */
  56 public class ManagedRepositoryContentMock implements ManagedRepositoryContent
  57 {
  58     private static final String PATH_SEPARATOR = "/";
  59     private static final String GROUP_SEPARATOR = ".";
  60     public static final String MAVEN_METADATA = "maven-metadata.xml";
  61
  62
  63     private ManagedRepository repository;
  64     private FilesystemStorage fsStorage;
  65
  66     public ManagedRepositoryContentMock(ManagedRepository repo) {
  67         this.repository = repo;
  68     }
  69
  70     @Override
  71     public VersionedReference toVersion( String groupId, String artifactId, String version )
  72     {
  73         return null;
  74     }
  75
  76     @Override
  77     public VersionedReference toGenericVersion( ArtifactReference artifactReference )
  78     {
  79         return null;
  80     }
  81
  82     @Override
  83     public VersionedReference toVersion( ArtifactReference artifactReference )
  84     {
  85         return null;
  86     }
  87
  88     @Override
  89     public ArtifactReference toArtifact( String groupId, String artifactId, String version, String type, String classifier )
  90     {
  91         return null;
  92     }
  93
  94     @Override
  95     public void deleteItem( ContentItem item ) throws ItemNotFoundException, ContentAccessException
  96     {
  97
  98     }
  99
 100     @Override
 101     public ContentItem getItem( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 102     {
 103         return null;
 104     }
 105
 106     @Override
 107     public Namespace getNamespace( ItemSelector namespaceSelector ) throws ContentAccessException, IllegalArgumentException
 108     {
 109         return null;
 110     }
 111
 112     @Override
 113     public Project getProject( ItemSelector projectSelector ) throws ContentAccessException, IllegalArgumentException
 114     {
 115         return null;
 116     }
 117
 118     @Override
 119     public Version getVersion( ItemSelector versionCoordinates ) throws ContentAccessException, IllegalArgumentException
 120     {
 121         return null;
 122     }
 123
 124     @Override
 125     public Artifact getArtifact( ItemSelector selector ) throws ContentAccessException
 126     {
 127         return null;
 128     }
 129
 130     @Override
 131     public List<? extends Artifact> getArtifacts( ItemSelector selector ) throws ContentAccessException
 132     {
 133         return null;
 134     }
 135
 136     @Override
 137     public Stream<? extends Artifact> getArtifactStream( ItemSelector selector ) throws ContentAccessException
 138     {
 139         return null;
 140     }
 141
 142     @Override
 143     public List<? extends Project> getProjects( Namespace namespace ) throws ContentAccessException
 144     {
 145         return null;
 146     }
 147
 148     @Override
 149     public List<? extends Project> getProjects( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 150     {
 151         return null;
 152     }
 153
 154     @Override
 155     public List<? extends Version> getVersions( Project project ) throws ContentAccessException
 156     {
 157         return null;
 158     }
 159
 160     @Override
 161     public List<? extends Version> getVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 162     {
 163         return null;
 164     }
 165
 166     @Override
 167     public List<? extends Artifact> getArtifacts( ContentItem item ) throws ContentAccessException
 168     {
 169         return null;
 170     }
 171
 172     @Override
 173     public List<? extends Artifact> getArtifacts( Namespace namespace, boolean recurse ) throws ContentAccessException
 174     {
 175         return null;
 176     }
 177
 178     @Override
 179     public Stream<? extends Artifact> getArtifactStream( ContentItem item ) throws ContentAccessException
 180     {
 181         return null;
 182     }
 183
 184     @Override
 185     public Stream<? extends Artifact> getArtifactStream( Namespace namespace, boolean recurse ) throws ContentAccessException
 186     {
 187         return null;
 188     }
 189
 190     @Override
 191     public boolean hasContent( ItemSelector selector )
 192     {
 193         return false;
 194     }
 195
 196     @Override
 197     public void copyArtifact( Path sourceFile, ContentItem destination ) throws IllegalArgumentException
 198     {
 199
 200     }
 201
 202     @Override
 203     public ContentItem toItem( String path ) throws LayoutException
 204     {
 205         return null;
 206     }
 207
 208     @Override
 209     public ContentItem toItem( StorageAsset assetPath ) throws LayoutException
 210     {
 211         return null;
 212     }
 213
 214     @Override
 215     public void deleteVersion( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException
 216     {
 217
 218     }
 219
 220     @Override
 221     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException, ContentAccessException
 222     {
 223
 224     }
 225
 226     @Override
 227     public void deleteGroupId( String groupId ) throws ContentNotFoundException, ContentAccessException
 228     {
 229
 230     }
 231
 232     @Override
 233     public void deleteProject( String namespace, String projectId ) throws ContentNotFoundException, ContentAccessException
 234     {
 235
 236     }
 237
 238     @Override
 239     public void deleteProject( ProjectReference reference ) throws ContentNotFoundException, ContentAccessException
 240     {
 241
 242     }
 243
 244     @Override
 245     public String getId( )
 246     {
 247         return repository.getId();
 248     }
 249
 250     @Override
 251     public List<ArtifactReference> getRelatedArtifacts( ArtifactReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 252     {
 253         return null;
 254     }
 255
 256     @Override
 257     public List<ArtifactReference> getRelatedArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 258     {
 259         return null;
 260     }
 261
 262     @Override
 263     public List<StorageAsset> getRelatedAssets( ArtifactReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 264     {
 265         return null;
 266     }
 267
 268     @Override
 269     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 270     {
 271         return null;
 272     }
 273
 274     @Override
 275     public String getRepoRoot( )
 276     {
 277         return getRepoRootAsset().getFilePath().toString();
 278     }
 279
 280     private StorageAsset getRepoRootAsset() {
 281         if (fsStorage==null) {
 282             try {
 283                 fsStorage = new FilesystemStorage(Paths.get("", "target", "test-repository", "managed"), new DefaultFileLockManager());
 284             } catch (IOException e) {
 285                 e.printStackTrace();
 286             }
 287         }
 288         return fsStorage.getAsset("");
 289     }
 290
 291     @Override
 292     public ManagedRepository getRepository( )
 293     {
 294         return repository;
 295     }
 296
 297     @Override
 298     public Set<String> getVersions( ProjectReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 299     {
 300         return null;
 301     }
 302
 303     @Override
 304     public Set<String> getVersions( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException, LayoutException
 305     {
 306         return null;
 307     }
 308
 309     @Override
 310     public boolean hasContent( ArtifactReference reference ) throws ContentAccessException
 311     {
 312         return false;
 313     }
 314
 315     @Override
 316     public boolean hasContent( ProjectReference reference ) throws ContentAccessException
 317     {
 318         return false;
 319     }
 320
 321     @Override
 322     public boolean hasContent( VersionedReference reference ) throws ContentAccessException
 323     {
 324         return false;
 325     }
 326
 327     @Override
 328     public void setRepository( ManagedRepository repo )
 329     {
 330         this.repository = repo;
 331     }
 332
 333     @Override
 334     public StorageAsset toFile( VersionedReference reference )
 335     {
 336         return null;
 337     }
 338
 339     private Map<ArtifactReference, String> refs = new HashMap<>();
 340
 341     @Override
 342     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 343     {
 344         if ( StringUtils.isBlank( path ) )
 345         {
 346             throw new LayoutException( "Unable to convert blank path." );
 347         }
 348
 349         ArtifactMetadata metadata = getArtifactForPath("test-repository", path);
 350
 351         ArtifactReference artifact = new ArtifactReference();
 352         artifact.setGroupId( metadata.getNamespace() );
 353         artifact.setArtifactId( metadata.getProject() );
 354         artifact.setVersion( metadata.getVersion() );
 355         MavenArtifactFacet facet = (MavenArtifactFacet) metadata.getFacet( MavenArtifactFacet.FACET_ID );
 356         if ( facet != null )
 357         {
 358             artifact.setClassifier( facet.getClassifier() );
 359             artifact.setType( facet.getType() );
 360         }
 361         refs.put(artifact, path);
 362         return artifact;
 363     }
 364
 365     public ArtifactMetadata getArtifactForPath( String repoId, String relativePath )
 366     {
 367         String[] parts = relativePath.replace( '\\', '/' ).split( "/" );
 368
 369         int len = parts.length;
 370         if ( len < 4 )
 371         {
 372             throw new IllegalArgumentException(
 373                     "Not a valid artifact path in a Maven 2 repository, not enough directories: " + relativePath );
 374         }
 375
 376         String id = parts[--len];
 377         String baseVersion = parts[--len];
 378         String artifactId = parts[--len];
 379         StringBuilder groupIdBuilder = new StringBuilder();
 380         for ( int i = 0; i < len - 1; i++ )
 381         {
 382             groupIdBuilder.append( parts[i] );
 383             groupIdBuilder.append( '.' );
 384         }
 385         groupIdBuilder.append( parts[len - 1] );
 386
 387         return getArtifactFromId( repoId, groupIdBuilder.toString(), artifactId, baseVersion, id );
 388     }
 389
 390     private static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "([0-9]{8}.[0-9]{6})-([0-9]+).*" );
 391
 392
 393
 394     public ArtifactMetadata getArtifactFromId( String repoId, String namespace, String projectId, String projectVersion,
 395                                                String id )
 396     {
 397         if ( !id.startsWith( projectId + "-" ) )
 398         {
 399             throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 400                     + "' doesn't start with artifact ID '" + projectId + "'" );
 401         }
 402
 403         MavenArtifactFacet facet = new MavenArtifactFacet();
 404
 405         int index = projectId.length() + 1;
 406         String version;
 407         String idSubStrFromVersion = id.substring( index );
 408         if ( idSubStrFromVersion.startsWith( projectVersion ) && !VersionUtil.isUniqueSnapshot( projectVersion ) )
 409         {
 410             // non-snapshot versions, or non-timestamped snapshot versions
 411             version = projectVersion;
 412         }
 413         else if ( VersionUtil.isGenericSnapshot( projectVersion ) )
 414         {
 415             // timestamped snapshots
 416             try
 417             {
 418                 int mainVersionLength = projectVersion.length() - 8; // 8 is length of "SNAPSHOT"
 419                 if ( mainVersionLength == 0 )
 420                 {
 421                     throw new IllegalArgumentException(
 422                             "Timestamped snapshots must contain the main version, filename was '" + id + "'" );
 423                 }
 424
 425                 Matcher m = TIMESTAMP_PATTERN.matcher( idSubStrFromVersion.substring( mainVersionLength ) );
 426                 m.matches();
 427                 String timestamp = m.group( 1 );
 428                 String buildNumber = m.group( 2 );
 429                 facet.setTimestamp( timestamp );
 430                 facet.setBuildNumber( Integer.parseInt( buildNumber ) );
 431                 version = idSubStrFromVersion.substring( 0, mainVersionLength ) + timestamp + "-" + buildNumber;
 432             }
 433             catch ( IllegalStateException e )
 434             {
 435                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 436                         + "' doesn't contain a timestamped version matching snapshot '"
 437                         + projectVersion + "'", e);
 438             }
 439         }
 440         else
 441         {
 442             // invalid
 443             throw new IllegalArgumentException(
 444                     "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' doesn't contain version '"
 445                             + projectVersion + "'" );
 446         }
 447
 448         String classifier;
 449         String ext;
 450         index += version.length();
 451         if ( index == id.length() )
 452         {
 453             // no classifier or extension
 454             classifier = null;
 455             ext = null;
 456         }
 457         else
 458         {
 459             char c = id.charAt( index );
 460             if ( c == '-' )
 461             {
 462                 // classifier up until '.'
 463                 int extIndex = id.indexOf( '.', index );
 464                 if ( extIndex >= 0 )
 465                 {
 466                     classifier = id.substring( index + 1, extIndex );
 467                     ext = id.substring( extIndex + 1 );
 468                 }
 469                 else
 470                 {
 471                     classifier = id.substring( index + 1 );
 472                     ext = null;
 473                 }
 474             }
 475             else if ( c == '.' )
 476             {
 477                 // rest is the extension
 478                 classifier = null;
 479                 ext = id.substring( index + 1 );
 480             }
 481             else
 482             {
 483                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 484                         + "' expected classifier or extension but got '"
 485                         + id.substring( index ) + "'" );
 486             }
 487         }
 488
 489         ArtifactMetadata metadata = new ArtifactMetadata();
 490         metadata.setId( id );
 491         metadata.setNamespace( namespace );
 492         metadata.setProject( projectId );
 493         metadata.setRepositoryId( repoId );
 494         metadata.setProjectVersion( projectVersion );
 495         metadata.setVersion( version );
 496
 497         facet.setClassifier( classifier );
 498
 499         // we use our own provider here instead of directly accessing Maven's artifact handlers as it has no way
 500         // to select the correct order to apply multiple extensions mappings to a preferred type
 501         // TODO: this won't allow the user to decide order to apply them if there are conflicts or desired changes -
 502         //       perhaps the plugins could register missing entries in configuration, then we just use configuration
 503         //       here?
 504
 505         String type = null;
 506
 507
 508         // use extension as default
 509         if ( type == null )
 510         {
 511             type = ext;
 512         }
 513
 514         // TODO: should we allow this instead?
 515         if ( type == null )
 516         {
 517             throw new IllegalArgumentException(
 518                     "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' does not have a type" );
 519         }
 520
 521         facet.setType( type );
 522         metadata.addFacet( facet );
 523
 524         return metadata;
 525     }
 526
 527
 528     @Override
 529     public StorageAsset toFile( ArtifactReference reference )
 530     {
 531         return getRepoRootAsset().resolve(refs.get(reference));
 532     }
 533
 534     @Override
 535     public StorageAsset toFile( ArchivaArtifact reference )
 536     {
 537         return null;
 538     }
 539
 540     private String formatAsDirectory( String directory )
 541     {
 542         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 543     }
 544
 545     public String toMetadataPath( ProjectReference reference )
 546     {
 547         StringBuilder path = new StringBuilder();
 548
 549         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 550         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 551         path.append( MAVEN_METADATA );
 552
 553         return path.toString();
 554     }
 555
 556     public String toMetadataPath( VersionedReference reference )
 557     {
 558         StringBuilder path = new StringBuilder();
 559
 560         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 561         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 562         if ( reference.getVersion() != null )
 563         {
 564             // add the version only if it is present
 565             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
 566         }
 567         path.append( MAVEN_METADATA );
 568
 569         return path.toString();
 570     }
 571
 572     @Override
 573     public String toPath( ArtifactReference reference )
 574     {
 575         return null;
 576     }
 577
 578     @Override
 579     public String toPath( ItemSelector selector )
 580     {
 581         return null;
 582     }
 583
 584     @Override
 585     public ItemSelector toItemSelector( String path ) throws LayoutException
 586     {
 587         return null;
 588     }
 589
 590     @Override
 591     public String toPath( ArchivaArtifact reference )
 592     {
 593         return null;
 594     }
 595
 596 }