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

   1 package org.apache.archiva.repository.maven.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  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import org.apache.archiva.model.ArtifactReference;
  22 import org.apache.archiva.repository.*;
  23 import org.apache.archiva.repository.content.PathParser;
  24 import org.apache.archiva.repository.features.RepositoryFeature;
  25 import org.apache.archiva.repository.metadata.base.MetadataTools;
  26 import org.apache.commons.lang3.StringUtils;
  27
  28 /**
  29  * RepositoryRequest is used to determine the type of request that is incoming, and convert it to an appropriate
  30  * ArtifactReference.
  31  */
  32 public class MavenRepositoryRequestInfo implements RepositoryRequestInfo
  33 {
  34     private PathParser defaultPathParser = new DefaultPathParser();
  35
  36     ManagedRepository repository;
  37
  38     public MavenRepositoryRequestInfo(ManagedRepository repository)
  39     {
  40         this.repository = repository;
  41     }
  42
  43     /**
  44      * Takes an incoming requested path (in "/" format) and gleans the layout
  45      * and ArtifactReference appropriate for that content.
  46      *
  47      * @param requestedPath the relative path to the content.
  48      * @return the ArtifactReference for the requestedPath.
  49      * @throws LayoutException if the request path is not layout valid.
  50      */
  51     public ArtifactReference toArtifactReference( String requestedPath )
  52         throws LayoutException
  53     {
  54         if ( StringUtils.isBlank( requestedPath ) )
  55         {
  56             throw new LayoutException( "Blank request path is not a valid." );
  57         }
  58
  59         String path = requestedPath;
  60         while ( path.startsWith( "/" ) )
  61         {
  62             path = path.substring( 1 );
  63
  64             // Only slash? that's bad, mmm-kay?
  65             if ( "/".equals( path ) )
  66             {
  67                 throw new LayoutException( "Invalid request path: Slash only." );
  68             }
  69         }
  70
  71         if ( isDefault( path ) )
  72         {
  73             return defaultPathParser.toArtifactReference( path );
  74         }
  75         else if ( isLegacy( path ) )
  76         {
  77             throw new LayoutException( "Legacy Maven1 repository not supported anymore." );
  78         }
  79         else
  80         {
  81             throw new LayoutException( "Not a valid request path layout, too short." );
  82         }
  83     }
  84
  85     /**
  86      * <p>
  87      * Tests the path to see if it conforms to the expectations of a metadata request.
  88      * </p>
  89      * <p>
  90      * NOTE: This does a cursory check on the path's last element.  A result of true
  91      * from this method is not a guarantee that the metadata is in a valid format, or
  92      * that it even contains data.
  93      * </p>
  94      *
  95      * @param requestedPath the path to test.
  96      * @return true if the requestedPath is likely a metadata request.
  97      */
  98     public boolean isMetadata( String requestedPath )
  99     {
 100         return requestedPath.endsWith( "/" + MetadataTools.MAVEN_METADATA );
 101     }
 102
 103     /**
 104      * @param requestedPath
 105      * @return true if the requestedPath is likely an archetype catalog request.
 106      */
 107     public boolean isArchetypeCatalog( String requestedPath )
 108     {
 109         return requestedPath.endsWith( "/" + MetadataTools.MAVEN_ARCHETYPE_CATALOG );
 110     }
 111
 112     /**
 113      * <p>
 114      * Tests the path to see if it conforms to the expectations of a support file request.
 115      * </p>
 116      * <p>
 117      * Tests for <code>.sha1</code>, <code>.md5</code>, <code>.asc</code>, and <code>.php</code>.
 118      * </p>
 119      * <p>
 120      * NOTE: This does a cursory check on the path's extension only.  A result of true
 121      * from this method is not a guarantee that the support resource is in a valid format, or
 122      * that it even contains data.
 123      * </p>
 124      *
 125      * @param requestedPath the path to test.
 126      * @return true if the requestedPath is likely that of a support file request.
 127      */
 128     public boolean isSupportFile( String requestedPath )
 129     {
 130         int idx = requestedPath.lastIndexOf( '.' );
 131         if ( idx <= 0 )
 132         {
 133             return false;
 134         }
 135
 136         String ext = requestedPath.substring( idx );
 137         return ( ".sha1".equals( ext ) || ".md5".equals( ext ) || ".asc".equals( ext ) || ".pgp".equals( ext ) );
 138     }
 139
 140     public boolean isMetadataSupportFile( String requestedPath )
 141     {
 142         if ( isSupportFile( requestedPath ) )
 143         {
 144             String basefilePath = StringUtils.substring( requestedPath, 0, requestedPath.lastIndexOf( '.' ) );
 145             if ( isMetadata( basefilePath ) )
 146             {
 147                 return true;
 148             }
 149         }
 150
 151         return false;
 152     }
 153
 154     @Override
 155     public String getLayout(String requestPath) {
 156         if (isDefault(requestPath)) {
 157             return "default";
 158         } else if (isLegacy(requestPath)) {
 159             return "legacy";
 160         } else {
 161             return "unknown";
 162         }
 163     }
 164
 165     /**
 166      * <p>
 167      * Tests the path to see if it conforms to the expectations of a default layout request.
 168      * </p>
 169      * <p>
 170      * NOTE: This does a cursory check on the count of path elements only.  A result of
 171      * true from this method is not a guarantee that the path sections are valid and
 172      * can be resolved to an artifact reference.  use {@link #toArtifactReference(String)}
 173      * if you want a more complete analysis of the validity of the path.
 174      * </p>
 175      *
 176      * @param requestedPath the path to test.
 177      * @return true if the requestedPath is likely that of a default layout request.
 178      */
 179     private boolean isDefault( String requestedPath )
 180     {
 181         if ( StringUtils.isBlank( requestedPath ) )
 182         {
 183             return false;
 184         }
 185
 186         String pathParts[] = StringUtils.splitPreserveAllTokens( requestedPath, '/' );
 187         if ( pathParts.length > 3 )
 188         {
 189             return true;
 190         }
 191         else if ( pathParts.length == 3 )
 192         {
 193             // check if artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml)
 194             if ( isMetadata( requestedPath ) )
 195             {
 196                 return true;
 197             }
 198             else
 199             {
 200                 // check if checksum of artifact-level metadata (ex. eclipse/jdtcore/maven-metadata.xml.sha1)
 201                 int idx = requestedPath.lastIndexOf( '.' );
 202                 if ( idx > 0 )
 203                 {
 204                     String base = requestedPath.substring( 0, idx );
 205                     if ( isMetadata( base ) && isSupportFile( requestedPath ) )
 206                     {
 207                         return true;
 208                     }
 209                 }
 210
 211                 return false;
 212             }
 213         }
 214         else
 215         {
 216             return false;
 217         }
 218     }
 219
 220     /**
 221      * <p>
 222      * Tests the path to see if it conforms to the expectations of a legacy layout request.
 223      * </p>
 224      * <p>
 225      * NOTE: This does a cursory check on the count of path elements only.  A result of
 226      * true from this method is not a guarantee that the path sections are valid and
 227      * can be resolved to an artifact reference.  use {@link #toArtifactReference(String)}
 228      * if you want a more complete analysis of the validity of the path.
 229      * </p>
 230      *
 231      * @param requestedPath the path to test.
 232      * @return true if the requestedPath is likely that of a legacy layout request.
 233      */
 234     private boolean isLegacy( String requestedPath )
 235     {
 236         if ( StringUtils.isBlank( requestedPath ) )
 237         {
 238             return false;
 239         }
 240
 241         String pathParts[] = StringUtils.splitPreserveAllTokens( requestedPath, '/' );
 242         return pathParts.length == 3;
 243     }
 244
 245     /**
 246      * Adjust the requestedPath to conform to the native layout of the provided {@link BaseRepositoryContentLayout}.
 247      *
 248      * @param requestedPath the incoming requested path.
 249      * @return the adjusted (to native) path.
 250      * @throws LayoutException if the path cannot be parsed.
 251      */
 252     public String toNativePath( String requestedPath)
 253         throws LayoutException
 254     {
 255         if ( StringUtils.isBlank( requestedPath ) )
 256         {
 257             throw new LayoutException( "Request Path is blank." );
 258         }
 259
 260         String referencedResource = requestedPath;
 261         // No checksum by default.
 262         String supportfile = "";
 263
 264         // Figure out support file, and actual referencedResource.
 265         if ( isSupportFile( requestedPath ) )
 266         {
 267             int idx = requestedPath.lastIndexOf( '.' );
 268             referencedResource = requestedPath.substring( 0, idx );
 269             supportfile = requestedPath.substring( idx );
 270         }
 271
 272         if ( isMetadata( referencedResource ) )
 273         {
 274             /* Nothing to translate.
 275              * Default layout is the only layout that can contain maven-metadata.xml files, and
 276              * if the managedRepository is layout legacy, this request would never occur.
 277              */
 278             return requestedPath;
 279         }
 280
 281         // Treat as an artifact reference.
 282         ArtifactReference ref = toArtifactReference( referencedResource );
 283         String adjustedPath = repository.getContent().getLayout( BaseRepositoryContentLayout.class ).toPath( ref );
 284         return adjustedPath + supportfile;
 285     }
 286
 287     @Override
 288     public <T extends RepositoryFeature<T>> RepositoryFeature<T> getFeature(Class<T> clazz) throws UnsupportedFeatureException {
 289         return null;
 290     }
 291
 292     @Override
 293     public <T extends RepositoryFeature<T>> boolean supportsFeature(Class<T> clazz) {
 294         return false;
 295     }
 296 }