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