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