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

   1 package org.apache.archiva.repository.content.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.common.utils.VersionUtil;
  23 import org.apache.archiva.metadata.repository.storage.RepositoryPathTranslator;
  24 import org.apache.archiva.metadata.repository.storage.maven2.ArtifactMappingProvider;
  25 import org.apache.archiva.metadata.repository.storage.maven2.Maven2RepositoryPathTranslator;
  26 import org.apache.archiva.model.ArchivaArtifact;
  27 import org.apache.archiva.model.ArtifactReference;
  28 import org.apache.archiva.model.ProjectReference;
  29 import org.apache.archiva.model.VersionedReference;
  30 import org.apache.archiva.repository.LayoutException;
  31 import org.apache.archiva.repository.RepositoryContent;
  32 import org.apache.archiva.repository.content.PathParser;
  33 import org.apache.commons.lang3.StringUtils;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 import java.util.List;
  38
  39 /**
  40  * AbstractDefaultRepositoryContent - common methods for working with default (maven 2) layout.
  41  */
  42 public abstract class AbstractDefaultRepositoryContent implements RepositoryContent
  43 {
  44
  45
  46     protected Logger log = LoggerFactory.getLogger( getClass() );
  47
  48     public static final String MAVEN_METADATA = "maven-metadata.xml";
  49
  50     protected static final char PATH_SEPARATOR = '/';
  51
  52     protected static final char GROUP_SEPARATOR = '.';
  53
  54     protected static final char ARTIFACT_SEPARATOR = '-';
  55
  56     private RepositoryPathTranslator pathTranslator = new Maven2RepositoryPathTranslator();
  57
  58     private PathParser defaultPathParser = new DefaultPathParser();
  59
  60
  61
  62     /**
  63      *
  64      */
  65     protected List<? extends ArtifactMappingProvider> artifactMappingProviders;
  66
  67     AbstractDefaultRepositoryContent(List<? extends ArtifactMappingProvider> artifactMappingProviders) {
  68         this.artifactMappingProviders = artifactMappingProviders;
  69     }
  70
  71     public void setArtifactMappingProviders(List<? extends ArtifactMappingProvider> artifactMappingProviders) {
  72         this.artifactMappingProviders = artifactMappingProviders;
  73     }
  74
  75     @Override
  76     public ArtifactReference toArtifactReference( String path )
  77         throws LayoutException
  78     {
  79         return defaultPathParser.toArtifactReference( path );
  80     }
  81
  82     public String toPath (ProjectReference reference) {
  83         final StringBuilder path = new StringBuilder();
  84         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
  85         path.append( reference.getArtifactId( ) );
  86         return path.toString( );
  87     }
  88
  89     public String toMetadataPath( ProjectReference reference )
  90     {
  91         final StringBuilder path = new StringBuilder();
  92         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
  93         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
  94         path.append( MAVEN_METADATA );
  95         return path.toString();
  96     }
  97
  98     public String toPath( String namespace )
  99     {
 100         return formatAsDirectory( namespace );
 101     }
 102
 103     public String toPath( VersionedReference reference )
 104     {
 105         final StringBuilder path = new StringBuilder();
 106         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 107         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 108         if ( reference.getVersion() != null )
 109         {
 110             // add the version only if it is present
 111             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) );
 112         }
 113         return path.toString();
 114     }
 115
 116     public String toMetadataPath( VersionedReference reference )
 117     {
 118         StringBuilder path = new StringBuilder();
 119
 120         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
 121         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
 122         if ( reference.getVersion() != null )
 123         {
 124             // add the version only if it is present
 125             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
 126         }
 127         path.append( MAVEN_METADATA );
 128
 129         return path.toString();
 130     }
 131
 132     public String toPath( ArchivaArtifact reference )
 133     {
 134         if ( reference == null )
 135         {
 136             throw new IllegalArgumentException( "ArchivaArtifact cannot be null" );
 137         }
 138
 139         String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
 140         return toPath( reference.getGroupId(), reference.getArtifactId(), baseVersion, reference.getVersion(),
 141                        reference.getClassifier(), reference.getType() );
 142     }
 143
 144     public String toPath( ArtifactReference reference )
 145     {
 146         if ( reference == null )
 147         {
 148             throw new IllegalArgumentException( "Artifact reference cannot be null" );
 149         }
 150         if ( reference.getVersion() != null )
 151         {
 152             String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
 153             return toPath( reference.getGroupId(), reference.getArtifactId(), baseVersion, reference.getVersion(),
 154                            reference.getClassifier(), reference.getType() );
 155         }
 156         return toPath( reference.getGroupId(), reference.getArtifactId(), null, null,
 157                        reference.getClassifier(), reference.getType() );
 158     }
 159
 160     private String formatAsDirectory( String directory )
 161     {
 162         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 163     }
 164
 165     private String toPath( String groupId, String artifactId, String baseVersion, String version, String classifier,
 166                            String type )
 167     {
 168         if ( baseVersion != null )
 169         {
 170             return pathTranslator.toPath( groupId, artifactId, baseVersion,
 171                                           constructId( artifactId, version, classifier, type ) );
 172         }
 173         else
 174         {
 175             return pathTranslator.toPath( groupId, artifactId );
 176         }
 177     }
 178
 179     // TODO: move into the Maven Artifact facet when refactoring away the caller - the caller will need to have access
 180     //       to the facet or filename (for the original ID)
 181     private String constructId( String artifactId, String version, String classifier, String type )
 182     {
 183         String ext = null;
 184         for ( ArtifactMappingProvider provider : artifactMappingProviders )
 185         {
 186             ext = provider.mapTypeToExtension( type );
 187             if ( ext != null )
 188             {
 189                 break;
 190             }
 191         }
 192         if ( ext == null )
 193         {
 194             ext = type;
 195         }
 196
 197         StringBuilder id = new StringBuilder();
 198         if ( ( version != null ) && ( type != null ) )
 199         {
 200             id.append( artifactId ).append( ARTIFACT_SEPARATOR ).append( version );
 201
 202             if ( StringUtils.isNotBlank( classifier ) )
 203             {
 204                 id.append( ARTIFACT_SEPARATOR ).append( classifier );
 205             }
 206
 207             id.append( "." ).append( ext );
 208         }
 209         return id.toString();
 210     }
 211 }