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