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

   1 package org.apache.maven.archiva.repository.layout;
   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.commons.lang.StringUtils;
  23 import org.apache.maven.archiva.model.ArchivaArtifact;
  24 import org.apache.maven.archiva.model.ArtifactReference;
  25 import org.apache.maven.archiva.repository.content.ArtifactExtensionMapping;
  26
  27 import java.util.HashMap;
  28 import java.util.Map;
  29
  30 /**
  31  * LegacyBidirectionalRepositoryLayout - the layout mechanism for use by Maven 1.x repositories.
  32  *
  33  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  34  * @version $Id$
  35  * @plexus.component role-hint="legacy"
  36  */
  37 public class LegacyBidirectionalRepositoryLayout
  38     implements BidirectionalRepositoryLayout
  39 {
  40     private static final String DIR_JAVADOC = "javadoc.jars";
  41
  42     private static final String DIR_JAVA_SOURCE = "java-sources";
  43
  44     private static final String PATH_SEPARATOR = "/";
  45
  46     private Map typeToDirectoryMap;
  47
  48     public LegacyBidirectionalRepositoryLayout()
  49     {
  50         typeToDirectoryMap = new HashMap();
  51         typeToDirectoryMap.put( "ejb-client", "ejb" );
  52         typeToDirectoryMap.put( "distribution-tgz", "distribution" );
  53         typeToDirectoryMap.put( "distribution-zip", "distribution" );
  54     }
  55
  56     public String getId()
  57     {
  58         return "legacy";
  59     }
  60
  61     public String toPath( ArchivaArtifact artifact )
  62     {
  63         return toPath( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(),
  64                        artifact.getClassifier(), artifact.getType() );
  65     }
  66
  67     public String toPath( ArtifactReference reference )
  68     {
  69         return toPath( reference.getGroupId(), reference.getArtifactId(), reference.getVersion(), reference
  70             .getClassifier(), reference.getType() );
  71     }
  72
  73     private String toPath( String groupId, String artifactId, String version, String classifier, String type )
  74     {
  75         StringBuffer path = new StringBuffer();
  76
  77         path.append( groupId ).append( PATH_SEPARATOR );
  78         path.append( getDirectory( classifier, type ) ).append( PATH_SEPARATOR );
  79
  80         if ( version != null )
  81         {
  82             path.append( artifactId ).append( '-' ).append( version );
  83
  84             if ( StringUtils.isNotBlank( classifier ) )
  85             {
  86                 path.append( '-' ).append( classifier );
  87             }
  88
  89             path.append( '.' ).append( ArtifactExtensionMapping.getExtension( type ) );
  90         }
  91
  92         return path.toString();
  93     }
  94
  95     private String getDirectory( String classifier, String type )
  96     {
  97         // Special Cases involving type + classifier
  98         if ( "jar".equals( type ) && StringUtils.isNotBlank( classifier ) )
  99         {
 100             if ( "sources".equals( classifier ) )
 101             {
 102                 return DIR_JAVA_SOURCE;
 103             }
 104
 105             if ( "javadoc".equals( classifier ) )
 106             {
 107                 return DIR_JAVADOC;
 108             }
 109         }
 110
 111         // Special Cases involving only type.
 112         String dirname = (String) typeToDirectoryMap.get( type );
 113
 114         if ( dirname != null )
 115         {
 116             return dirname + "s";
 117         }
 118
 119         // Default process.
 120         return type + "s";
 121     }
 122
 123     class PathReferences
 124     {
 125         public String groupId;
 126
 127         public String pathType;
 128
 129         public String type;
 130
 131         public FilenameParts fileParts;
 132     }
 133
 134     private PathReferences toPathReferences( String path )
 135         throws LayoutException
 136     {
 137         PathReferences prefs = new PathReferences();
 138
 139         String normalizedPath = StringUtils.replace( path, "\\", "/" );
 140
 141         String pathParts[] = StringUtils.split( normalizedPath, '/' );
 142
 143         /* Always 3 parts. (Never more or less)
 144          *
 145          *   path = "commons-lang/jars/commons-lang-2.1.jar"
 146          *   path[0] = "commons-lang";          // The Group ID
 147          *   path[1] = "jars";                  // The Directory Type
 148          *   path[2] = "commons-lang-2.1.jar";  // The Filename.
 149          */
 150
 151         if ( pathParts.length != 3 )
 152         {
 153             // Illegal Path Parts Length.
 154             throw new LayoutException( "Invalid number of parts to the path [" + path
 155                 + "] to construct an ArchivaArtifact from. (Required to be 3 parts)" );
 156         }
 157
 158         // The Group ID.
 159         prefs.groupId = pathParts[0];
 160
 161         // The Expected Type.
 162         prefs.pathType = pathParts[1];
 163
 164         // The Filename.
 165         String filename = pathParts[2];
 166
 167         prefs.fileParts = RepositoryLayoutUtils.splitFilename( filename, null );
 168
 169         String trimPathType = prefs.pathType.substring( 0, prefs.pathType.length() - 1 );
 170         prefs.type = ArtifactExtensionMapping.guessTypeFromFilename( filename );
 171
 172         // Sanity Check: does it have an extension?
 173         if ( StringUtils.isEmpty( prefs.fileParts.extension ) )
 174         {
 175             throw new LayoutException( "Invalid artifact, no extension." );
 176         }
 177
 178         // Sanity Check: pathType should end in "s".
 179         if ( !prefs.pathType.toLowerCase().endsWith( "s" ) )
 180         {
 181             throw new LayoutException( "Invalid path, the type specified in the path <" + prefs.pathType
 182                 + "> does not end in the letter <s>." );
 183         }
 184
 185         // Sanity Check: does extension match pathType on path?
 186         String expectedExtension = ArtifactExtensionMapping.getExtension( trimPathType );
 187         String actualExtension = prefs.fileParts.extension;
 188
 189         if ( !expectedExtension.equals( actualExtension ) )
 190         {
 191             throw new LayoutException( "Invalid artifact, mismatch on extension <" + prefs.fileParts.extension
 192                 + "> and layout specified type <" + prefs.pathType + "> (which maps to extension: <"
 193                 + expectedExtension + ">) on path <" + path + ">" );
 194         }
 195
 196         return prefs;
 197     }
 198
 199     public boolean isValidPath( String path )
 200     {
 201         try
 202         {
 203             toPathReferences( path );
 204             return true;
 205         }
 206         catch ( LayoutException e )
 207         {
 208             return false;
 209         }
 210     }
 211
 212     public ArchivaArtifact toArtifact( String path )
 213         throws LayoutException
 214     {
 215         PathReferences pathrefs = toPathReferences( path );
 216
 217         ArchivaArtifact artifact = new ArchivaArtifact( pathrefs.groupId, pathrefs.fileParts.artifactId,
 218                                                         pathrefs.fileParts.version, pathrefs.fileParts.classifier,
 219                                                         pathrefs.type );
 220
 221         return artifact;
 222     }
 223
 224     public ArtifactReference toArtifactReference( String path )
 225         throws LayoutException
 226     {
 227         PathReferences pathrefs = toPathReferences( path );
 228
 229         ArtifactReference reference = new ArtifactReference();
 230
 231         reference.setGroupId( pathrefs.groupId );
 232         reference.setArtifactId( pathrefs.fileParts.artifactId );
 233         reference.setVersion( pathrefs.fileParts.version );
 234         reference.setClassifier( pathrefs.fileParts.classifier );
 235         reference.setType( pathrefs.type );
 236
 237         return reference;
 238     }
 239 }