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.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.storage.FilesystemStorage;
  32 import org.apache.archiva.repository.storage.StorageAsset;
  33 import org.apache.commons.lang3.StringUtils;
  34
  35 import java.io.IOException;
  36 import java.nio.file.Paths;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import java.util.regex.Matcher;
  42 import java.util.regex.Pattern;
  43
  44 /**
  45  * @author Martin Stockhammer <martin_s@apache.org>
  46  */
  47 public class ManagedRepositoryContentMock implements ManagedRepositoryContent
  48 {
  49     private static final String PATH_SEPARATOR = "/";
  50     private static final String GROUP_SEPARATOR = ".";
  51     public static final String MAVEN_METADATA = "maven-metadata.xml";
  52
  53
  54     private ManagedRepository repository;
  55     private FilesystemStorage fsStorage;
  56
  57     public ManagedRepositoryContentMock(ManagedRepository repo) {
  58         this.repository = repo;
  59     }
  60
  61     @Override
  62     public VersionedReference toVersion( String groupId, String artifactId, String version )
  63     {
  64         return null;
  65     }
  66
  67     @Override
  68     public VersionedReference toVersion( ArtifactReference artifactReference )
  69     {
  70         return null;
  71     }
  72
  73     @Override
  74     public ArtifactReference toArtifact( String groupId, String artifactId, String version, String type, String classifier )
  75     {
  76         return null;
  77     }
  78
  79     @Override
  80     public void deleteVersion( VersionedReference reference ) throws ContentNotFoundException
  81     {
  82
  83     }
  84
  85     @Override
  86     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException
  87     {
  88
  89     }
  90
  91     @Override
  92     public void deleteGroupId( String groupId ) throws ContentNotFoundException
  93     {
  94
  95     }
  96
  97     @Override
  98     public void deleteProject( String namespace, String projectId ) throws RepositoryException
  99     {
 100
 101     }
 102
 103     @Override
 104     public String getId( )
 105     {
 106         return repository.getId();
 107     }
 108
 109     @Override
 110     public List<ArtifactReference> getRelatedArtifacts( ArtifactReference reference ) throws ContentNotFoundException, LayoutException
 111     {
 112         return null;
 113     }
 114
 115     @Override
 116     public List<StorageAsset> getRelatedAssets( ArtifactReference reference ) throws ContentNotFoundException, LayoutException
 117     {
 118         return null;
 119     }
 120
 121     @Override
 122     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException
 123     {
 124         return null;
 125     }
 126
 127     @Override
 128     public String getRepoRoot( )
 129     {
 130         return getRepoRootAsset().getFilePath().toString();
 131     }
 132
 133     private StorageAsset getRepoRootAsset() {
 134         if (fsStorage==null) {
 135             try {
 136                 fsStorage = new FilesystemStorage(Paths.get("", "target", "test-repository", "managed"), new DefaultFileLockManager());
 137             } catch (IOException e) {
 138                 e.printStackTrace();
 139             }
 140         }
 141         return fsStorage.getAsset("");
 142     }
 143
 144     @Override
 145     public ManagedRepository getRepository( )
 146     {
 147         return repository;
 148     }
 149
 150     @Override
 151     public Set<String> getVersions( ProjectReference reference ) throws ContentNotFoundException, LayoutException
 152     {
 153         return null;
 154     }
 155
 156     @Override
 157     public Set<String> getVersions( VersionedReference reference ) throws ContentNotFoundException
 158     {
 159         return null;
 160     }
 161
 162     @Override
 163     public boolean hasContent( ArtifactReference reference )
 164     {
 165         return false;
 166     }
 167
 168     @Override
 169     public boolean hasContent( ProjectReference reference )
 170     {
 171         return false;
 172     }
 173
 174     @Override
 175     public boolean hasContent( VersionedReference reference )
 176     {
 177         return false;
 178     }
 179
 180     @Override
 181     public void setRepository( ManagedRepository repo )
 182     {
 183         this.repository = repo;
 184     }
 185
 186     private Map<ArtifactReference, String> refs = new HashMap<>();
 187
 188     @Override
 189     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 190     {
 191         if ( StringUtils.isBlank( path ) )
 192         {
 193             throw new LayoutException( "Unable to convert blank path." );
 194         }
 195
 196         ArtifactMetadata metadata = getArtifactForPath("test-repository", path);
 197
 198         ArtifactReference artifact = new ArtifactReference();
 199         artifact.setGroupId( metadata.getNamespace() );
 200         artifact.setArtifactId( metadata.getProject() );
 201         artifact.setVersion( metadata.getVersion() );
 202         MavenArtifactFacet facet = (MavenArtifactFacet) metadata.getFacet( MavenArtifactFacet.FACET_ID );
 203         if ( facet != null )
 204         {
 205             artifact.setClassifier( facet.getClassifier() );
 206             artifact.setType( facet.getType() );
 207         }
 208         refs.put(artifact, path);
 209         return artifact;
 210     }
 211
 212     public ArtifactMetadata getArtifactForPath( String repoId, String relativePath )
 213     {
 214         String[] parts = relativePath.replace( '\\', '/' ).split( "/" );
 215
 216         int len = parts.length;
 217         if ( len < 4 )
 218         {
 219             throw new IllegalArgumentException(
 220                     "Not a valid artifact path in a Maven 2 repository, not enough directories: " + relativePath );
 221         }
 222
 223         String id = parts[--len];
 224         String baseVersion = parts[--len];
 225         String artifactId = parts[--len];
 226         StringBuilder groupIdBuilder = new StringBuilder();
 227         for ( int i = 0; i < len - 1; i++ )
 228         {
 229             groupIdBuilder.append( parts[i] );
 230             groupIdBuilder.append( '.' );
 231         }
 232         groupIdBuilder.append( parts[len - 1] );
 233
 234         return getArtifactFromId( repoId, groupIdBuilder.toString(), artifactId, baseVersion, id );
 235     }
 236
 237     private static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "([0-9]{8}.[0-9]{6})-([0-9]+).*" );
 238
 239
 240
 241     public ArtifactMetadata getArtifactFromId( String repoId, String namespace, String projectId, String projectVersion,
 242                                                String id )
 243     {
 244         if ( !id.startsWith( projectId + "-" ) )
 245         {
 246             throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 247                     + "' doesn't start with artifact ID '" + projectId + "'" );
 248         }
 249
 250         MavenArtifactFacet facet = new MavenArtifactFacet();
 251
 252         int index = projectId.length() + 1;
 253         String version;
 254         String idSubStrFromVersion = id.substring( index );
 255         if ( idSubStrFromVersion.startsWith( projectVersion ) && !VersionUtil.isUniqueSnapshot( projectVersion ) )
 256         {
 257             // non-snapshot versions, or non-timestamped snapshot versions
 258             version = projectVersion;
 259         }
 260         else if ( VersionUtil.isGenericSnapshot( projectVersion ) )
 261         {
 262             // timestamped snapshots
 263             try
 264             {
 265                 int mainVersionLength = projectVersion.length() - 8; // 8 is length of "SNAPSHOT"
 266                 if ( mainVersionLength == 0 )
 267                 {
 268                     throw new IllegalArgumentException(
 269                             "Timestamped snapshots must contain the main version, filename was '" + id + "'" );
 270                 }
 271
 272                 Matcher m = TIMESTAMP_PATTERN.matcher( idSubStrFromVersion.substring( mainVersionLength ) );
 273                 m.matches();
 274                 String timestamp = m.group( 1 );
 275                 String buildNumber = m.group( 2 );
 276                 facet.setTimestamp( timestamp );
 277                 facet.setBuildNumber( Integer.parseInt( buildNumber ) );
 278                 version = idSubStrFromVersion.substring( 0, mainVersionLength ) + timestamp + "-" + buildNumber;
 279             }
 280             catch ( IllegalStateException e )
 281             {
 282                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 283                         + "' doesn't contain a timestamped version matching snapshot '"
 284                         + projectVersion + "'", e);
 285             }
 286         }
 287         else
 288         {
 289             // invalid
 290             throw new IllegalArgumentException(
 291                     "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' doesn't contain version '"
 292                             + projectVersion + "'" );
 293         }
 294
 295         String classifier;
 296         String ext;
 297         index += version.length();
 298         if ( index == id.length() )
 299         {
 300             // no classifier or extension
 301             classifier = null;
 302             ext = null;
 303         }
 304         else
 305         {
 306             char c = id.charAt( index );
 307             if ( c == '-' )
 308             {
 309                 // classifier up until '.'
 310                 int extIndex = id.indexOf( '.', index );
 311                 if ( extIndex >= 0 )
 312                 {
 313                     classifier = id.substring( index + 1, extIndex );
 314                     ext = id.substring( extIndex + 1 );
 315                 }
 316                 else
 317                 {
 318                     classifier = id.substring( index + 1 );
 319                     ext = null;
 320                 }
 321             }
 322             else if ( c == '.' )
 323             {
 324                 // rest is the extension
 325                 classifier = null;
 326                 ext = id.substring( index + 1 );
 327             }
 328             else
 329             {
 330                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 331                         + "' expected classifier or extension but got '"
 332                         + id.substring( index ) + "'" );
 333             }
 334         }
 335
 336         ArtifactMetadata metadata = new ArtifactMetadata();
 337         metadata.setId( id );
 338         metadata.setNamespace( namespace );
 339         metadata.setProject( projectId );
 340         metadata.setRepositoryId( repoId );
 341         metadata.setProjectVersion( projectVersion );
 342         metadata.setVersion( version );
 343
 344         facet.setClassifier( classifier );
 345
 346         // we use our own provider here instead of directly accessing Maven's artifact handlers as it has no way
 347         // to select the correct order to apply multiple extensions mappings to a preferred type
 348         // TODO: this won't allow the user to decide order to apply them if there are conflicts or desired changes -
 349         //       perhaps the plugins could register missing entries in configuration, then we just use configuration
 350         //       here?
 351
 352         String type = null;
 353
 354
 355         // use extension as default
 356         if ( type == null )
 357         {
 358             type = ext;
 359         }
 360
 361         // TODO: should we allow this instead?
 362         if ( type == null )
 363         {
 364             throw new IllegalArgumentException(
 365                     "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' does not have a type" );
 366         }
 367
 368         facet.setType( type );
 369         metadata.addFacet( facet );
 370
 371         return metadata;
 372     }
 373
 374
 375     @Override
 376     public StorageAsset toFile( ArtifactReference reference )
 377     {
 378         return getRepoRootAsset().resolve(refs.get(reference));
 379     }
 380
 381     @Override
 382     public StorageAsset toFile( ArchivaArtifact reference )
 383     {
 384         return null;
 385     }
 386
 387     private String formatAsDirectory( String directory )
 388     {
 389         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 390     }
 391
 392     public String toMetadataPath( ProjectReference reference )
 393     {
 394         StringBuilder path = new StringBuilder();
 395
 396         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 397         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 398         path.append( MAVEN_METADATA );
 399
 400         return path.toString();
 401     }
 402
 403     public String toMetadataPath( VersionedReference reference )
 404     {
 405         StringBuilder path = new StringBuilder();
 406
 407         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 408         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 409         if ( reference.getVersion() != null )
 410         {
 411             // add the version only if it is present
 412             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
 413         }
 414         path.append( MAVEN_METADATA );
 415
 416         return path.toString();
 417     }
 418
 419     @Override
 420     public String toPath( ArtifactReference reference )
 421     {
 422         return null;
 423     }
 424
 425     @Override
 426     public String toPath( ArchivaArtifact reference )
 427     {
 428         return null;
 429     }
 430
 431 }