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