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

   1 package org.apache.archiva.metadata.repository.storage.maven2;
   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.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
  24 import org.apache.maven.archiva.common.utils.VersionUtil;
  25 import org.springframework.context.ApplicationContext;
  26 import org.springframework.stereotype.Service;
  27
  28 import javax.annotation.PostConstruct;
  29 import javax.inject.Inject;
  30 import java.io.File;
  31 import java.util.ArrayList;
  32 import java.util.List;
  33 import java.util.regex.Matcher;
  34 import java.util.regex.Pattern;
  35
  36 /**
  37  * plexus.component role="org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator" role-hint="maven2"
  38  */
  39 @Service( "repositoryPathTranslator#maven2" )
  40 public class Maven2RepositoryPathTranslator
  41     implements RepositoryPathTranslator
  42 {
  43     private static final char PATH_SEPARATOR = '/';
  44
  45     private static final char GROUP_SEPARATOR = '.';
  46
  47     private static final Pattern TIMESTAMP_PATTERN = Pattern.compile( "([0-9]{8}.[0-9]{6})-([0-9]+).*" );
  48
  49     //@Inject
  50     //private ApplicationContext applicationContext;
  51
  52     /**
  53      * plexus.requirement role="org.apache.archiva.metadata.repository.storage.maven2.ArtifactMappingProvider"
  54      * see #initialize
  55      */
  56     @Inject
  57     private List<ArtifactMappingProvider> artifactMappingProviders;
  58
  59     public Maven2RepositoryPathTranslator()
  60     {
  61         // noop
  62     }
  63
  64     @PostConstruct
  65     public void initialize()
  66     {
  67
  68         //artifactMappingProviders = new ArrayList<ArtifactMappingProvider>(
  69         //    applicationContext.getBeansOfType( ArtifactMappingProvider.class ).values() );
  70
  71     }
  72
  73
  74     public Maven2RepositoryPathTranslator( List<ArtifactMappingProvider> artifactMappingProviders )
  75     {
  76         this.artifactMappingProviders = artifactMappingProviders;
  77     }
  78
  79     public File toFile( File basedir, String namespace, String projectId, String projectVersion, String filename )
  80     {
  81         return new File( basedir, toPath( namespace, projectId, projectVersion, filename ) );
  82     }
  83
  84     public File toFile( File basedir, String namespace, String projectId, String projectVersion )
  85     {
  86         return new File( basedir, toPath( namespace, projectId, projectVersion ) );
  87     }
  88
  89     public String toPath( String namespace, String projectId, String projectVersion, String filename )
  90     {
  91         StringBuilder path = new StringBuilder();
  92
  93         appendNamespaceToProjectVersion( path, namespace, projectId, projectVersion );
  94         path.append( PATH_SEPARATOR );
  95         path.append( filename );
  96
  97         return path.toString();
  98     }
  99
 100     private void appendNamespaceToProjectVersion( StringBuilder path, String namespace, String projectId,
 101                                                   String projectVersion )
 102     {
 103         appendNamespaceAndProject( path, namespace, projectId );
 104         path.append( projectVersion );
 105     }
 106
 107     public String toPath( String namespace, String projectId, String projectVersion )
 108     {
 109         StringBuilder path = new StringBuilder();
 110
 111         appendNamespaceToProjectVersion( path, namespace, projectId, projectVersion );
 112
 113         return path.toString();
 114     }
 115
 116     public String toPath( String namespace )
 117     {
 118         StringBuilder path = new StringBuilder();
 119
 120         appendNamespace( path, namespace );
 121
 122         return path.toString();
 123     }
 124
 125     public String toPath( String namespace, String projectId )
 126     {
 127         StringBuilder path = new StringBuilder();
 128
 129         appendNamespaceAndProject( path, namespace, projectId );
 130
 131         return path.toString();
 132     }
 133
 134     private void appendNamespaceAndProject( StringBuilder path, String namespace, String projectId )
 135     {
 136         appendNamespace( path, namespace );
 137         path.append( projectId ).append( PATH_SEPARATOR );
 138     }
 139
 140     private void appendNamespace( StringBuilder path, String namespace )
 141     {
 142         path.append( formatAsDirectory( namespace ) ).append( PATH_SEPARATOR );
 143     }
 144
 145     public File toFile( File basedir, String namespace, String projectId )
 146     {
 147         return new File( basedir, toPath( namespace, projectId ) );
 148     }
 149
 150     public File toFile( File basedir, String namespace )
 151     {
 152         return new File( basedir, toPath( namespace ) );
 153     }
 154
 155     private String formatAsDirectory( String directory )
 156     {
 157         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 158     }
 159
 160     public ArtifactMetadata getArtifactForPath( String repoId, String relativePath )
 161     {
 162         String[] parts = relativePath.replace( '\\', '/' ).split( "/" );
 163
 164         int len = parts.length;
 165         if ( len < 4 )
 166         {
 167             throw new IllegalArgumentException(
 168                 "Not a valid artifact path in a Maven 2 repository, not enough directories: " + relativePath );
 169         }
 170
 171         String id = parts[--len];
 172         String baseVersion = parts[--len];
 173         String artifactId = parts[--len];
 174         StringBuilder groupIdBuilder = new StringBuilder();
 175         for ( int i = 0; i < len - 1; i++ )
 176         {
 177             groupIdBuilder.append( parts[i] );
 178             groupIdBuilder.append( '.' );
 179         }
 180         groupIdBuilder.append( parts[len - 1] );
 181
 182         return getArtifactFromId( repoId, groupIdBuilder.toString(), artifactId, baseVersion, id );
 183     }
 184
 185     public ArtifactMetadata getArtifactFromId( String repoId, String namespace, String projectId, String projectVersion,
 186                                                String id )
 187     {
 188         if ( !id.startsWith( projectId + "-" ) )
 189         {
 190             throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 191                                                     + "' doesn't start with artifact ID '" + projectId + "'" );
 192         }
 193
 194         MavenArtifactFacet facet = new MavenArtifactFacet();
 195
 196         int index = projectId.length() + 1;
 197         String version;
 198         String idSubStrFromVersion = id.substring( index );
 199         if ( idSubStrFromVersion.startsWith( projectVersion ) && !VersionUtil.isUniqueSnapshot( projectVersion ) )
 200         {
 201             // non-snapshot versions, or non-timestamped snapshot versions
 202             version = projectVersion;
 203         }
 204         else if ( VersionUtil.isGenericSnapshot( projectVersion ) )
 205         {
 206             // timestamped snapshots
 207             try
 208             {
 209                 int mainVersionLength = projectVersion.length() - 8; // 8 is length of "SNAPSHOT"
 210                 if ( mainVersionLength == 0 )
 211                 {
 212                     throw new IllegalArgumentException(
 213                         "Timestamped snapshots must contain the main version, filename was '" + id + "'" );
 214                 }
 215
 216                 Matcher m = TIMESTAMP_PATTERN.matcher( idSubStrFromVersion.substring( mainVersionLength ) );
 217                 m.matches();
 218                 String timestamp = m.group( 1 );
 219                 String buildNumber = m.group( 2 );
 220                 facet.setTimestamp( timestamp );
 221                 facet.setBuildNumber( Integer.parseInt( buildNumber ) );
 222                 version = idSubStrFromVersion.substring( 0, mainVersionLength ) + timestamp + "-" + buildNumber;
 223             }
 224             catch ( IllegalStateException e )
 225             {
 226                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 227                                                         + "' doesn't contain a timestamped version matching snapshot '"
 228                                                         + projectVersion + "'" );
 229             }
 230         }
 231         else
 232         {
 233             // invalid
 234             throw new IllegalArgumentException(
 235                 "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' doesn't contain version '"
 236                     + projectVersion + "'" );
 237         }
 238
 239         String classifier;
 240         String ext;
 241         index += version.length();
 242         if ( index == id.length() )
 243         {
 244             // no classifier or extension
 245             classifier = null;
 246             ext = null;
 247         }
 248         else
 249         {
 250             char c = id.charAt( index );
 251             if ( c == '-' )
 252             {
 253                 // classifier up until '.'
 254                 int extIndex = id.indexOf( '.', index );
 255                 if ( extIndex >= 0 )
 256                 {
 257                     classifier = id.substring( index + 1, extIndex );
 258                     ext = id.substring( extIndex + 1 );
 259                 }
 260                 else
 261                 {
 262                     classifier = id.substring( index + 1 );
 263                     ext = null;
 264                 }
 265             }
 266             else if ( c == '.' )
 267             {
 268                 // rest is the extension
 269                 classifier = null;
 270                 ext = id.substring( index + 1 );
 271             }
 272             else
 273             {
 274                 throw new IllegalArgumentException( "Not a valid artifact path in a Maven 2 repository, filename '" + id
 275                                                         + "' expected classifier or extension but got '"
 276                                                         + id.substring( index ) + "'" );
 277             }
 278         }
 279
 280         ArtifactMetadata metadata = new ArtifactMetadata();
 281         metadata.setId( id );
 282         metadata.setNamespace( namespace );
 283         metadata.setProject( projectId );
 284         metadata.setRepositoryId( repoId );
 285         metadata.setProjectVersion( projectVersion );
 286         metadata.setVersion( version );
 287
 288         facet.setClassifier( classifier );
 289
 290         // we use our own provider here instead of directly accessing Maven's artifact handlers as it has no way
 291         // to select the correct order to apply multiple extensions mappings to a preferred type
 292         // TODO: this won't allow the user to decide order to apply them if there are conflicts or desired changes -
 293         //       perhaps the plugins could register missing entries in configuration, then we just use configuration
 294         //       here?
 295
 296         String type = null;
 297         for ( ArtifactMappingProvider mapping : artifactMappingProviders )
 298         {
 299             type = mapping.mapClassifierAndExtensionToType( classifier, ext );
 300             if ( type != null )
 301             {
 302                 break;
 303             }
 304         }
 305
 306         // TODO: this is cheating! We should check the POM metadata instead
 307         if ( type == null && "jar".equals( ext ) && isArtifactIdValidMavenPlugin( projectId ) )
 308         {
 309             type = "maven-plugin";
 310         }
 311
 312         // use extension as default
 313         if ( type == null )
 314         {
 315             type = ext;
 316         }
 317
 318         // TODO: should we allow this instead?
 319         if ( type == null )
 320         {
 321             throw new IllegalArgumentException(
 322                 "Not a valid artifact path in a Maven 2 repository, filename '" + id + "' does not have a type" );
 323         }
 324
 325         facet.setType( type );
 326         metadata.addFacet( facet );
 327
 328         return metadata;
 329     }
 330
 331     private static final Pattern MAVEN_PLUGIN_PATTERN = Pattern.compile( "^(maven-.*-plugin)|(.*-maven-plugin)$" );
 332
 333     public boolean isArtifactIdValidMavenPlugin( String artifactId )
 334     {
 335         return MAVEN_PLUGIN_PATTERN.matcher( artifactId ).matches();
 336     }
 337 }