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