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