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