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