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.metadata.model.ArtifactMetadata;
  25 import org.apache.archiva.metadata.model.maven2.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.RepositoryStorage;
  40 import org.apache.archiva.repository.storage.StorageAsset;
  41 import org.apache.commons.lang3.StringUtils;
  42 import org.springframework.stereotype.Service;
  43
  44 import java.io.IOException;
  45 import java.nio.file.Path;
  46 import java.nio.file.Paths;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Set;
  51 import java.util.regex.Matcher;
  52 import java.util.regex.Pattern;
  53 import java.util.stream.Stream;
  54
  55 /**
  56  * @author Martin Stockhammer <martin_s@apache.org>
  57  */
  58 @Service("managedRepositoryContent#mock")
  59 public class ManagedRepositoryContentMock implements 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 RepositoryStorage fsStorage;
  68
  69     ManagedRepositoryContentMock(ManagedRepository repo) {
  70         this.repository = repo;
  71         this.fsStorage = repo;
  72     }
  73
  74     @Override
  75     public VersionedReference toVersion( String groupId, String artifactId, String version )
  76     {
  77         return null;
  78     }
  79
  80     @Override
  81     public VersionedReference toGenericVersion( ArtifactReference artifactReference )
  82     {
  83         return null;
  84     }
  85
  86     @Override
  87     public VersionedReference toVersion( ArtifactReference artifactReference )
  88     {
  89         return null;
  90     }
  91
  92     @Override
  93     public ArtifactReference toArtifact( String groupId, String artifactId, String version, String type, String classifier )
  94     {
  95         return null;
  96     }
  97
  98     @Override
  99     public void deleteItem( ContentItem item ) throws ItemNotFoundException, ContentAccessException
 100     {
 101
 102     }
 103
 104     @Override
 105     public ContentItem getItem( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 106     {
 107         return null;
 108     }
 109
 110     @Override
 111     public Namespace getNamespace( ItemSelector namespaceSelector ) throws ContentAccessException, IllegalArgumentException
 112     {
 113         return null;
 114     }
 115
 116     @Override
 117     public Project getProject( ItemSelector projectSelector ) throws ContentAccessException, IllegalArgumentException
 118     {
 119         return null;
 120     }
 121
 122     @Override
 123     public Version getVersion( ItemSelector versionCoordinates ) throws ContentAccessException, IllegalArgumentException
 124     {
 125         return null;
 126     }
 127
 128     @Override
 129     public Artifact getArtifact( ItemSelector selector ) throws ContentAccessException
 130     {
 131         return null;
 132     }
 133
 134     @Override
 135     public List<? extends Artifact> getAllArtifacts( ItemSelector selector ) throws ContentAccessException
 136     {
 137         return null;
 138     }
 139
 140     @Override
 141     public Stream<? extends Artifact> getAllArtifactStream( ItemSelector selector ) throws ContentAccessException
 142     {
 143         return null;
 144     }
 145
 146     @Override
 147     public List<? extends Project> getProjects( Namespace namespace ) throws ContentAccessException
 148     {
 149         return null;
 150     }
 151
 152     @Override
 153     public List<? extends Version> getVersions( Project project ) throws ContentAccessException
 154     {
 155         return null;
 156     }
 157
 158     @Override
 159     public List<? extends Artifact> getArtifacts( ContentItem item ) throws ContentAccessException
 160     {
 161         return null;
 162     }
 163
 164     @Override
 165     public List<? extends Artifact> getArtifacts( Namespace namespace, boolean recurse ) throws ContentAccessException
 166     {
 167         return null;
 168     }
 169
 170     @Override
 171     public Stream<? extends Artifact> getArtifactStream( ContentItem item ) throws ContentAccessException
 172     {
 173         return null;
 174     }
 175
 176     @Override
 177     public Stream<? extends Artifact> getArtifactStream( Namespace namespace, boolean recurse ) throws ContentAccessException
 178     {
 179         return null;
 180     }
 181
 182     @Override
 183     public boolean hasContent( ItemSelector selector )
 184     {
 185         return false;
 186     }
 187
 188     @Override
 189     public void copyArtifact( Path sourceFile, ContentItem destination ) throws IllegalArgumentException
 190     {
 191
 192     }
 193
 194     @Override
 195     public ContentItem toItem( String path ) throws LayoutException
 196     {
 197         return null;
 198     }
 199
 200     @Override
 201     public ContentItem toItem( StorageAsset assetPath ) throws LayoutException
 202     {
 203         return null;
 204     }
 205
 206     @Override
 207     public void deleteVersion( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException
 208     {
 209
 210     }
 211
 212     @Override
 213     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException, ContentAccessException
 214     {
 215
 216     }
 217
 218     @Override
 219     public void deleteGroupId( String groupId ) throws ContentNotFoundException, ContentAccessException
 220     {
 221
 222     }
 223
 224     @Override
 225     public void deleteProject( String namespace, String projectId ) throws ContentNotFoundException, ContentAccessException
 226     {
 227
 228     }
 229
 230     @Override
 231     public void deleteProject( ProjectReference reference ) throws ContentNotFoundException, ContentAccessException
 232     {
 233
 234     }
 235
 236     @Override
 237     public String getId( )
 238     {
 239         return repository.getId();
 240     }
 241
 242     @Override
 243     public List<ArtifactReference> getRelatedArtifacts( ArtifactReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 244     {
 245         return null;
 246     }
 247
 248     @Override
 249     public List<ArtifactReference> getRelatedArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 250     {
 251         return null;
 252     }
 253
 254     @Override
 255     public List<StorageAsset> getRelatedAssets( ArtifactReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 256     {
 257         return null;
 258     }
 259
 260     @Override
 261     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 262     {
 263         return null;
 264     }
 265
 266     @Override
 267     public String getRepoRoot( )
 268     {
 269         return getRepoRootAsset().getFilePath().toString();
 270     }
 271
 272     private StorageAsset getRepoRootAsset() {
 273         if (fsStorage==null) {
 274             try {
 275                 fsStorage = new FilesystemStorage(Paths.get("", "target", "test-repository", "managed"), new DefaultFileLockManager());
 276             } catch (IOException e) {
 277                 e.printStackTrace();
 278             }
 279         }
 280         return fsStorage.getAsset("");
 281     }
 282
 283     @Override
 284     public ManagedRepository getRepository( )
 285     {
 286         return repository;
 287     }
 288
 289     @Override
 290     public Set<String> getVersions( ProjectReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 291     {
 292         return null;
 293     }
 294
 295     @Override
 296     public Set<String> getVersions( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException, LayoutException
 297     {
 298         return null;
 299     }
 300
 301     @Override
 302     public boolean hasContent( ArtifactReference reference ) throws ContentAccessException
 303     {
 304         return false;
 305     }
 306
 307     @Override
 308     public boolean hasContent( ProjectReference reference ) throws ContentAccessException
 309     {
 310         return false;
 311     }
 312
 313     @Override
 314     public boolean hasContent( VersionedReference reference ) throws ContentAccessException
 315     {
 316         return false;
 317     }
 318
 319     @Override
 320     public void setRepository( ManagedRepository repo )
 321     {
 322         this.repository = repo;
 323     }
 324
 325     @Override
 326     public StorageAsset toFile( VersionedReference reference )
 327     {
 328         return null;
 329     }
 330
 331     private Map<ArtifactReference, String> refs = new HashMap<>();
 332
 333     @Override
 334     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 335     {
 336         if ( StringUtils.isBlank( path ) )
 337         {
 338             throw new LayoutException( "Unable to convert blank path." );
 339         }
 340
 341         ArtifactMetadata metadata = getArtifactForPath("test-repository", path);
 342
 343         ArtifactReference artifact = new ArtifactReference();
 344         artifact.setGroupId( metadata.getNamespace() );
 345         artifact.setArtifactId( metadata.getProject() );
 346         artifact.setVersion( metadata.getVersion() );
 347         MavenArtifactFacet facet = (MavenArtifactFacet) metadata.getFacet( MavenArtifactFacet.FACET_ID );
 348         if ( facet != null )
 349         {
 350             artifact.setClassifier( facet.getClassifier() );
 351             artifact.setType( facet.getType() );
 352         }
 353         refs.put(artifact, path);
 354         return artifact;
 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     @Override
 521     public StorageAsset toFile( ArtifactReference reference )
 522     {
 523         return getRepoRootAsset().resolve( refs.get(reference));
 524     }
 525
 526     @Override
 527     public StorageAsset toFile( ArchivaArtifact reference )
 528     {
 529         return null;
 530     }
 531
 532     private String formatAsDirectory( String directory )
 533     {
 534         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 535     }
 536
 537     public String toMetadataPath( ProjectReference reference )
 538     {
 539         StringBuilder path = new StringBuilder();
 540
 541         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 542         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 543         path.append( MAVEN_METADATA );
 544
 545         return path.toString();
 546     }
 547
 548     public String toMetadataPath( VersionedReference reference )
 549     {
 550         StringBuilder path = new StringBuilder();
 551
 552         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 553         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 554         if ( reference.getVersion() != null )
 555         {
 556             // add the version only if it is present
 557             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
 558         }
 559         path.append( MAVEN_METADATA );
 560
 561         return path.toString();
 562     }
 563
 564     @Override
 565     public String toPath( ArtifactReference reference )
 566     {
 567         return null;
 568     }
 569
 570     @Override
 571     public String toPath( ItemSelector selector )
 572     {
 573         return null;
 574     }
 575
 576     @Override
 577     public ItemSelector toItemSelector( String path ) throws LayoutException
 578     {
 579         return null;
 580     }
 581
 582     @Override
 583     public String toPath( ArchivaArtifact reference )
 584     {
 585         return null;
 586     }
 587
 588 }