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

   1 package org.apache.archiva.repository.content;
   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.repository.storage.RepositoryPathTranslator;
  23 import org.apache.archiva.metadata.repository.storage.maven2.ArtifactMappingProvider;
  24 import org.apache.archiva.metadata.repository.storage.maven2.Maven2RepositoryPathTranslator;
  25 import org.apache.commons.lang.StringUtils;
  26 import org.apache.archiva.common.utils.VersionUtil;
  27 import org.apache.archiva.model.ArchivaArtifact;
  28 import org.apache.archiva.model.ArtifactReference;
  29 import org.apache.archiva.model.ProjectReference;
  30 import org.apache.archiva.model.VersionedReference;
  31 import org.apache.archiva.repository.layout.LayoutException;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 import javax.annotation.PostConstruct;
  36 import javax.inject.Inject;
  37 import java.util.List;
  38
  39 /**
  40  * AbstractDefaultRepositoryContent - common methods for working with default (maven 2) layout.
  41  *
  42  * @version $Id$
  43  */
  44 public abstract class AbstractDefaultRepositoryContent
  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     @Inject
  64     protected List<? extends ArtifactMappingProvider> artifactMappingProviders;
  65
  66     @PostConstruct
  67     protected void initialize()
  68     {
  69         // no op
  70     }
  71
  72     public ArtifactReference toArtifactReference( String path )
  73         throws LayoutException
  74     {
  75         return defaultPathParser.toArtifactReference( path );
  76     }
  77
  78     public String toMetadataPath( ProjectReference reference )
  79     {
  80         StringBuilder path = new StringBuilder();
  81
  82         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
  83         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
  84         path.append( MAVEN_METADATA );
  85
  86         return path.toString();
  87     }
  88
  89     public String toMetadataPath( VersionedReference reference )
  90     {
  91         StringBuilder path = new StringBuilder();
  92
  93         path.append( formatAsDirectory( reference.getGroupId() ) ).append( PATH_SEPARATOR );
  94         path.append( reference.getArtifactId() ).append( PATH_SEPARATOR );
  95         if ( reference.getVersion() != null )
  96         {
  97             // add the version only if it is present
  98             path.append( VersionUtil.getBaseVersion( reference.getVersion() ) ).append( PATH_SEPARATOR );
  99         }
 100         path.append( MAVEN_METADATA );
 101
 102         return path.toString();
 103     }
 104
 105     public String toPath( ArchivaArtifact reference )
 106     {
 107         if ( reference == null )
 108         {
 109             throw new IllegalArgumentException( "ArchivaArtifact cannot be null" );
 110         }
 111
 112         String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
 113         return toPath( reference.getGroupId(), reference.getArtifactId(), baseVersion, reference.getVersion(),
 114                        reference.getClassifier(), reference.getType() );
 115     }
 116
 117     public String toPath( ArtifactReference reference )
 118     {
 119         if ( reference == null )
 120         {
 121             throw new IllegalArgumentException( "Artifact reference cannot be null" );
 122         }
 123
 124         String baseVersion = VersionUtil.getBaseVersion( reference.getVersion() );
 125         return toPath( reference.getGroupId(), reference.getArtifactId(), baseVersion, reference.getVersion(),
 126                        reference.getClassifier(), reference.getType() );
 127     }
 128
 129     private String formatAsDirectory( String directory )
 130     {
 131         return directory.replace( GROUP_SEPARATOR, PATH_SEPARATOR );
 132     }
 133
 134     private String toPath( String groupId, String artifactId, String baseVersion, String version, String classifier,
 135                            String type )
 136     {
 137         if ( baseVersion != null )
 138         {
 139             return pathTranslator.toPath( groupId, artifactId, baseVersion,
 140                                           constructId( artifactId, version, classifier, type ) );
 141         }
 142         else
 143         {
 144             return pathTranslator.toPath( groupId, artifactId );
 145         }
 146     }
 147
 148     // TODO: move into the Maven Artifact facet when refactoring away the caller - the caller will need to have access
 149     //       to the facet or filename (for the original ID)
 150     private String constructId( String artifactId, String version, String classifier, String type )
 151     {
 152         String ext = null;
 153         for ( ArtifactMappingProvider provider : artifactMappingProviders )
 154         {
 155             ext = provider.mapTypeToExtension( type );
 156             if ( ext != null )
 157             {
 158                 break;
 159             }
 160         }
 161         if ( ext == null )
 162         {
 163             ext = type;
 164         }
 165
 166         StringBuilder id = new StringBuilder();
 167         if ( ( version != null ) && ( type != null ) )
 168         {
 169             id.append( artifactId ).append( ARTIFACT_SEPARATOR ).append( version );
 170
 171             if ( StringUtils.isNotBlank( classifier ) )
 172             {
 173                 id.append( ARTIFACT_SEPARATOR ).append( classifier );
 174             }
 175
 176             id.append( "." ).append( ext );
 177         }
 178         return id.toString();
 179     }
 180 }