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

   1 package org.apache.archiva.repository.content.legacy;
   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.configuration.ArchivaConfiguration;
  23 import org.apache.archiva.configuration.LegacyArtifactPath;
  24 import org.apache.archiva.model.ArtifactReference;
  25 import org.apache.archiva.repository.content.ArtifactClassifierMapping;
  26 import org.apache.archiva.repository.content.PathParser;
  27 import org.apache.archiva.repository.content.maven2.ArtifactExtensionMapping;
  28 import org.apache.archiva.repository.content.maven2.FilenameParser;
  29 import org.apache.archiva.repository.layout.LayoutException;
  30 import org.apache.commons.lang.StringUtils;
  31
  32 import java.util.Collection;
  33
  34 /**
  35  * LegacyPathParser is a parser for maven 1 (legacy layout) paths to
  36  * ArtifactReference.
  37  *
  38  *
  39  */
  40 public class LegacyPathParser
  41     implements PathParser
  42 {
  43     private static final String INVALID_ARTIFACT_PATH = "Invalid path to Artifact: ";
  44
  45     protected ArchivaConfiguration configuration;
  46
  47     public LegacyPathParser( ArchivaConfiguration configuration )
  48     {
  49         this.configuration = configuration;
  50     }
  51
  52
  53     /**
  54      * {@inheritDoc}
  55      *
  56      * @see org.apache.archiva.repository.content.PathParser#toArtifactReference(String)
  57      */
  58     @Override
  59     public ArtifactReference toArtifactReference( String path )
  60         throws LayoutException
  61     {
  62         ArtifactReference artifact = new ArtifactReference();
  63
  64         // First, look if a custom resolution rule has been set for this artifact
  65         Collection<LegacyArtifactPath> legacy = configuration.getConfiguration().getLegacyArtifactPaths();
  66         for ( LegacyArtifactPath legacyPath : legacy )
  67         {
  68             if ( legacyPath.match( path ) )
  69             {
  70                 artifact.setGroupId( legacyPath.getGroupId() );
  71                 artifact.setArtifactId( legacyPath.getArtifactId() );
  72                 artifact.setClassifier( legacyPath.getClassifier() );
  73                 artifact.setVersion( legacyPath.getVersion() );
  74                 artifact.setType( legacyPath.getType() );
  75                 return artifact;
  76             }
  77         }
  78
  79         String normalizedPath = StringUtils.replace( path, "\\", "/" );
  80
  81         String pathParts[] = StringUtils.split( normalizedPath, '/' );
  82
  83         /* Always 3 parts. (Never more or less)
  84          *
  85          *   path = "commons-lang/jars/commons-lang-2.1.jar"
  86          *   path[0] = "commons-lang";          // The Group ID
  87          *   path[1] = "jars";                  // The Directory Type
  88          *   path[2] = "commons-lang-2.1.jar";  // The Filename.
  89          */
  90
  91         if ( pathParts.length != 3 )
  92         {
  93             // Illegal Path Parts Length.
  94             throw new LayoutException( INVALID_ARTIFACT_PATH
  95                                            + "legacy paths should only have 3 parts [groupId]/[type]s/[artifactId]-[version].[type], found "
  96                                            + pathParts.length + " instead." );
  97         }
  98
  99         // The Group ID.
 100         artifact.setGroupId( pathParts[0] );
 101
 102         // The Expected Type.
 103         String expectedType = pathParts[1];
 104
 105         // Sanity Check: expectedType should end in "s".
 106         if ( !expectedType.endsWith( "s" ) )
 107         {
 108             throw new LayoutException( INVALID_ARTIFACT_PATH
 109                                            + "legacy paths should have an expected type ending in [s] in the second part of the path." );
 110         }
 111
 112         // The Filename.
 113         String filename = pathParts[2];
 114
 115         FilenameParser parser = new FilenameParser( filename );
 116
 117         artifact.setArtifactId( parser.nextNonVersion() );
 118
 119         // Sanity Check: does it have an artifact id?
 120         if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 121         {
 122             // Special Case: The filename might start with a version id (like "test-arch-1.0.jar").
 123             int idx = filename.indexOf( '-' );
 124             if ( idx > 0 )
 125             {
 126                 parser.reset();
 127                 // Take the first section regardless of content.
 128                 String artifactId = parser.next();
 129
 130                 // Is there anything more that is considered not a version id?
 131                 String moreArtifactId = parser.nextNonVersion();
 132                 if ( StringUtils.isNotBlank( moreArtifactId ) )
 133                 {
 134                     artifact.setArtifactId( artifactId + "-" + moreArtifactId );
 135                 }
 136                 else
 137                 {
 138                     artifact.setArtifactId( artifactId );
 139                 }
 140             }
 141
 142             // Sanity Check: still no artifact id?
 143             if ( StringUtils.isEmpty( artifact.getArtifactId() ) )
 144             {
 145                 throw new LayoutException( INVALID_ARTIFACT_PATH + "no artifact id present." );
 146             }
 147         }
 148
 149         artifact.setVersion( parser.remaining() );
 150
 151         // Sanity Check: does it have a version?
 152         if ( StringUtils.isEmpty( artifact.getVersion() ) )
 153         {
 154             // Special Case: use last section of artifactId as version.
 155             String artifactId = artifact.getArtifactId();
 156             int idx = artifactId.lastIndexOf( '-' );
 157             if ( idx > 0 )
 158             {
 159                 artifact.setVersion( artifactId.substring( idx + 1 ) );
 160                 artifact.setArtifactId( artifactId.substring( 0, idx ) );
 161             }
 162             else
 163             {
 164                 throw new LayoutException( INVALID_ARTIFACT_PATH + "no version found." );
 165             }
 166         }
 167
 168         String classifier = ArtifactClassifierMapping.getClassifier( expectedType );
 169         if ( classifier != null )
 170         {
 171             String version = artifact.getVersion();
 172             if ( !version.endsWith( "-" + classifier ) )
 173             {
 174                 throw new LayoutException(
 175                     INVALID_ARTIFACT_PATH + expectedType + " artifacts must use the classifier " + classifier );
 176             }
 177             version = version.substring( 0, version.length() - classifier.length() - 1 );
 178             artifact.setVersion( version );
 179             artifact.setClassifier( classifier );
 180         }
 181
 182         String extension = parser.getExtension();
 183
 184         // Set Type
 185         String defaultExtension = expectedType.substring( 0, expectedType.length() - 1 );
 186         artifact.setType(
 187             ArtifactExtensionMapping.mapExtensionAndClassifierToType( classifier, extension, defaultExtension ) );
 188
 189         // Sanity Check: does it have an extension?
 190         if ( StringUtils.isEmpty( artifact.getType() ) )
 191         {
 192             throw new LayoutException( INVALID_ARTIFACT_PATH + "no extension found." );
 193         }
 194
 195         // Special Case with Maven Plugins
 196         if ( StringUtils.equals( "jar", extension ) && StringUtils.equals( "plugins", expectedType ) )
 197         {
 198             artifact.setType( ArtifactExtensionMapping.MAVEN_ONE_PLUGIN );
 199         }
 200         else
 201         {
 202             // Sanity Check: does extension match pathType on path?
 203             String expectedExtension = ArtifactExtensionMapping.getExtension( artifact.getType() );
 204
 205             if ( !expectedExtension.equals( extension ) )
 206             {
 207                 throw new LayoutException(
 208                     INVALID_ARTIFACT_PATH + "mismatch on extension [" + extension + "] and layout specified type ["
 209                         + artifact.getType() + "] (which maps to extension: [" + expectedExtension + "]) on path ["
 210                         + path + "]" );
 211             }
 212         }
 213
 214         return artifact;
 215     }
 216 }