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

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