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