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

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