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