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