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.commons.io.FileUtils;
  23 import org.apache.maven.archiva.common.utils.PathUtil;
  24 import org.apache.maven.archiva.configuration.FileTypes;
  25 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  26 import org.apache.maven.archiva.model.ArchivaArtifact;
  27 import org.apache.maven.archiva.model.ArtifactReference;
  28 import org.apache.maven.archiva.model.ProjectReference;
  29 import org.apache.maven.archiva.model.VersionedReference;
  30 import org.apache.maven.archiva.repository.ContentNotFoundException;
  31 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  32 import org.apache.maven.archiva.repository.layout.LayoutException;
  33
  34 import java.io.File;
  35 import java.io.IOException;
  36 import java.util.HashSet;
  37 import java.util.Set;
  38
  39 /**
  40  * ManagedDefaultRepositoryContent
  41  *
  42  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  43  * @version $Id$
  44  *
  45  * @todo no need to be a component when filetypes is not
  46  *
  47  * @plexus.component
  48  *      role="org.apache.maven.archiva.repository.ManagedRepositoryContent"
  49  *      role-hint="default"
  50  *      instantiation-strategy="per-lookup"
  51  */
  52 public class ManagedDefaultRepositoryContent
  53     extends AbstractDefaultRepositoryContent
  54     implements ManagedRepositoryContent
  55 {
  56     /**
  57      * @plexus.requirement
  58      */
  59     private FileTypes filetypes;
  60
  61     private ManagedRepositoryConfiguration repository;
  62
  63     public void deleteVersion( VersionedReference reference )
  64         throws ContentNotFoundException
  65     {
  66         String path = toMetadataPath( reference );
  67         File projectPath = new File( getRepoRoot(), path );
  68
  69         File projectDir = projectPath.getParentFile();
  70         if( projectDir.exists() && projectDir.isDirectory() )
  71         {
  72             try
  73             {
  74                 FileUtils.deleteDirectory( projectDir );
  75             }
  76             catch ( IOException e )
  77             {
  78                 // TODO: log this somewhere?
  79             }
  80         }
  81     }
  82
  83     public String getId()
  84     {
  85         return repository.getId();
  86     }
  87
  88     public Set<ArtifactReference> getRelatedArtifacts( ArtifactReference reference )
  89         throws ContentNotFoundException, LayoutException
  90     {
  91         File artifactFile = toFile( reference );
  92         File repoDir = artifactFile.getParentFile();
  93
  94         if ( !repoDir.exists() )
  95         {
  96             throw new ContentNotFoundException( "Unable to get related artifacts using a non-existant directory: "
  97                 + repoDir.getAbsolutePath() );
  98         }
  99
 100         if ( !repoDir.isDirectory() )
 101         {
 102             throw new ContentNotFoundException( "Unable to get related artifacts using a non-directory: "
 103                 + repoDir.getAbsolutePath() );
 104         }
 105
 106         Set<ArtifactReference> foundArtifacts = new HashSet<ArtifactReference>();
 107
 108         // First gather up the versions found as artifacts in the managed repository.
 109         File repoFiles[] = repoDir.listFiles();
 110         for ( int i = 0; i < repoFiles.length; i++ )
 111         {
 112             if ( repoFiles[i].isDirectory() )
 113             {
 114                 // Skip it. it's a directory.
 115                 continue;
 116             }
 117
 118             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 119
 120             if ( filetypes.matchesArtifactPattern( relativePath ) )
 121             {
 122                 ArtifactReference artifact = toArtifactReference( relativePath );
 123
 124                 // Test for related, groupId / artifactId / version must match.
 125                 if ( artifact.getGroupId().equals( reference.getGroupId() )
 126                     && artifact.getArtifactId().equals( reference.getArtifactId() )
 127                     && artifact.getVersion().equals( reference.getVersion() ) )
 128                 {
 129                     foundArtifacts.add( artifact );
 130                 }
 131             }
 132         }
 133
 134         return foundArtifacts;
 135     }
 136
 137     public String getRepoRoot()
 138     {
 139         return repository.getLocation();
 140     }
 141
 142     public ManagedRepositoryConfiguration getRepository()
 143     {
 144         return repository;
 145     }
 146
 147     /**
 148      * Gather the Available Versions (on disk) for a specific Project Reference, based on filesystem
 149      * information.
 150      *
 151      * @return the Set of available versions, based on the project reference.
 152      * @throws LayoutException
 153      * @throws LayoutException
 154      */
 155     public Set<String> getVersions( ProjectReference reference )
 156         throws ContentNotFoundException, LayoutException
 157     {
 158         String path = toMetadataPath( reference );
 159
 160         int idx = path.lastIndexOf( '/' );
 161         if ( idx > 0 )
 162         {
 163             path = path.substring( 0, idx );
 164         }
 165
 166         File repoDir = new File( repository.getLocation(), path );
 167
 168         if ( !repoDir.exists() )
 169         {
 170             throw new ContentNotFoundException( "Unable to get Versions on a non-existant directory: "
 171                 + repoDir.getAbsolutePath() );
 172         }
 173
 174         if ( !repoDir.isDirectory() )
 175         {
 176             throw new ContentNotFoundException( "Unable to get Versions on a non-directory: "
 177                 + repoDir.getAbsolutePath() );
 178         }
 179
 180         Set<String> foundVersions = new HashSet<String>();
 181         VersionedReference versionRef = new VersionedReference();
 182         versionRef.setGroupId( reference.getGroupId() );
 183         versionRef.setArtifactId( reference.getArtifactId() );
 184
 185         File repoFiles[] = repoDir.listFiles();
 186         for ( int i = 0; i < repoFiles.length; i++ )
 187         {
 188             if ( !repoFiles[i].isDirectory() )
 189             {
 190                 // Skip it. not a directory.
 191                 continue;
 192             }
 193
 194             // Test if dir has an artifact, which proves to us that it is a valid version directory.
 195             String version = repoFiles[i].getName();
 196             versionRef.setVersion( version );
 197
 198             if ( hasArtifact( versionRef ) )
 199             {
 200                 // Found an artifact, must be a valid version.
 201                 foundVersions.add( version );
 202             }
 203         }
 204
 205         return foundVersions;
 206     }
 207
 208     public Set<String> getVersions( VersionedReference reference )
 209         throws ContentNotFoundException, LayoutException
 210     {
 211         String path = toMetadataPath( reference );
 212
 213         int idx = path.lastIndexOf( '/' );
 214         if ( idx > 0 )
 215         {
 216             path = path.substring( 0, idx );
 217         }
 218
 219         File repoDir = new File( repository.getLocation(), path );
 220
 221         if ( !repoDir.exists() )
 222         {
 223             throw new ContentNotFoundException( "Unable to get versions on a non-existant directory: "
 224                 + repoDir.getAbsolutePath() );
 225         }
 226
 227         if ( !repoDir.isDirectory() )
 228         {
 229             throw new ContentNotFoundException( "Unable to get versions on a non-directory: "
 230                 + repoDir.getAbsolutePath() );
 231         }
 232
 233         Set<String> foundVersions = new HashSet<String>();
 234
 235         // First gather up the versions found as artifacts in the managed repository.
 236         File repoFiles[] = repoDir.listFiles();
 237         for ( int i = 0; i < repoFiles.length; i++ )
 238         {
 239             if ( repoFiles[i].isDirectory() )
 240             {
 241                 // Skip it. it's a directory.
 242                 continue;
 243             }
 244
 245             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 246
 247             if ( filetypes.matchesDefaultExclusions( relativePath ) )
 248             {
 249                 // Skip it, it's metadata or similar
 250                 continue;
 251             }
 252
 253             if ( filetypes.matchesArtifactPattern( relativePath ) )
 254             {
 255                 ArtifactReference artifact = toArtifactReference( relativePath );
 256
 257                 foundVersions.add( artifact.getVersion() );
 258             }
 259         }
 260
 261         return foundVersions;
 262     }
 263
 264     public boolean hasContent( ArtifactReference reference )
 265     {
 266         File artifactFile = toFile( reference );
 267         return artifactFile.exists() && artifactFile.isFile();
 268     }
 269
 270     public boolean hasContent( ProjectReference reference )
 271     {
 272         try
 273         {
 274             Set<String> versions = getVersions( reference );
 275             return !versions.isEmpty();
 276         }
 277         catch ( ContentNotFoundException e )
 278         {
 279             return false;
 280         }
 281         catch ( LayoutException e )
 282         {
 283             return false;
 284         }
 285     }
 286
 287     public boolean hasContent( VersionedReference reference )
 288     {
 289         try
 290         {
 291             return ( getFirstArtifact( reference ) != null );
 292         }
 293         catch ( IOException e )
 294         {
 295             return false;
 296         }
 297         catch ( LayoutException e )
 298         {
 299             return false;
 300         }
 301     }
 302
 303     public void setRepository( ManagedRepositoryConfiguration repository )
 304     {
 305         this.repository = repository;
 306     }
 307
 308     /**
 309      * Convert a path to an artifact reference.
 310      *
 311      * @param path the path to convert. (relative or full location path)
 312      * @throws LayoutException if the path cannot be converted to an artifact reference.
 313      */
 314     @Override
 315     public ArtifactReference toArtifactReference( String path )
 316         throws LayoutException
 317     {
 318         if ( ( path != null ) && path.startsWith( repository.getLocation() ) )
 319         {
 320             return super.toArtifactReference( path.substring( repository.getLocation().length() ) );
 321         }
 322
 323         return super.toArtifactReference( path );
 324     }
 325
 326     public File toFile( ArtifactReference reference )
 327     {
 328         return new File( repository.getLocation(), toPath( reference ) );
 329     }
 330
 331     public File toFile( ArchivaArtifact reference )
 332     {
 333         return new File( repository.getLocation(), toPath( reference ) );
 334     }
 335
 336     /**
 337      * Get the first Artifact found in the provided VersionedReference location.
 338      *
 339      * @param managedRepository the repository to search within.
 340      * @param reference         the reference to the versioned reference to search within
 341      * @return the ArtifactReference to the first artifact located within the versioned reference. or null if
 342      *         no artifact was found within the versioned reference.
 343      * @throws IOException     if the versioned reference is invalid (example: doesn't exist, or isn't a directory)
 344      * @throws LayoutException
 345      */
 346     private ArtifactReference getFirstArtifact( VersionedReference reference )
 347         throws LayoutException, IOException
 348     {
 349         String path = toMetadataPath( reference );
 350
 351         int idx = path.lastIndexOf( '/' );
 352         if ( idx > 0 )
 353         {
 354             path = path.substring( 0, idx );
 355         }
 356
 357         File repoDir = new File( repository.getLocation(), path );
 358
 359         if ( !repoDir.exists() )
 360         {
 361             throw new IOException( "Unable to gather the list of snapshot versions on a non-existant directory: "
 362                 + repoDir.getAbsolutePath() );
 363         }
 364
 365         if ( !repoDir.isDirectory() )
 366         {
 367             throw new IOException( "Unable to gather the list of snapshot versions on a non-directory: "
 368                 + repoDir.getAbsolutePath() );
 369         }
 370
 371         File repoFiles[] = repoDir.listFiles();
 372         for ( int i = 0; i < repoFiles.length; i++ )
 373         {
 374             if ( repoFiles[i].isDirectory() )
 375             {
 376                 // Skip it. it's a directory.
 377                 continue;
 378             }
 379
 380             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 381
 382             if ( filetypes.matchesArtifactPattern( relativePath ) )
 383             {
 384                 ArtifactReference artifact = toArtifactReference( relativePath );
 385
 386                 return artifact;
 387             }
 388         }
 389
 390         // No artifact was found.
 391         return null;
 392     }
 393
 394     private boolean hasArtifact( VersionedReference reference )
 395         throws LayoutException
 396     {
 397         try
 398         {
 399             return ( getFirstArtifact( reference ) != null );
 400         }
 401         catch ( IOException e )
 402         {
 403             return false;
 404         }
 405     }
 406 }