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 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  34 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  35 import org.codehaus.plexus.util.SelectorUtils;
  36
  37 import java.io.File;
  38 import java.io.IOException;
  39 import java.util.ArrayList;
  40 import java.util.HashSet;
  41 import java.util.Iterator;
  42 import java.util.List;
  43 import java.util.Set;
  44
  45 /**
  46  * ManagedDefaultRepositoryContent
  47  *
  48  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  49  * @version $Id$
  50  *
  51  * @plexus.component
  52  *      role="org.apache.maven.archiva.repository.ManagedRepositoryContent"
  53  *      role-hint="default"
  54  *      instantiation-strategy="per-lookup"
  55  */
  56 public class ManagedDefaultRepositoryContent
  57     extends AbstractDefaultRepositoryContent
  58     implements ManagedRepositoryContent, Initializable
  59 {
  60     /**
  61      * @plexus.requirement
  62      */
  63     private FileTypes filetypes;
  64
  65     private ManagedRepositoryConfiguration repository;
  66
  67     private List<String> artifactPatterns;
  68
  69     public void deleteVersion( VersionedReference reference )
  70         throws ContentNotFoundException
  71     {
  72         String path = toMetadataPath( reference );
  73         File projectPath = new File( getRepoRoot(), path );
  74
  75         File projectDir = projectPath.getParentFile();
  76         if( projectDir.exists() && projectDir.isDirectory() )
  77         {
  78             try
  79             {
  80                 FileUtils.deleteDirectory( projectDir );
  81             }
  82             catch ( IOException e )
  83             {
  84                 // TODO: log this somewhere?
  85             }
  86         }
  87     }
  88
  89     public String getId()
  90     {
  91         return repository.getId();
  92     }
  93
  94     public Set<ArtifactReference> getRelatedArtifacts( ArtifactReference reference )
  95         throws ContentNotFoundException, LayoutException
  96     {
  97         File artifactFile = toFile( reference );
  98         File repoDir = artifactFile.getParentFile();
  99
 100         if ( !repoDir.exists() )
 101         {
 102             throw new ContentNotFoundException( "Unable to get related artifacts using a non-existant directory: "
 103                 + repoDir.getAbsolutePath() );
 104         }
 105
 106         if ( !repoDir.isDirectory() )
 107         {
 108             throw new ContentNotFoundException( "Unable to get related artifacts using a non-directory: "
 109                 + repoDir.getAbsolutePath() );
 110         }
 111
 112         Set<ArtifactReference> foundArtifacts = new HashSet<ArtifactReference>();
 113
 114         // First gather up the versions found as artifacts in the managed repository.
 115         File repoFiles[] = repoDir.listFiles();
 116         for ( int i = 0; i < repoFiles.length; i++ )
 117         {
 118             if ( repoFiles[i].isDirectory() )
 119             {
 120                 // Skip it. it's a directory.
 121                 continue;
 122             }
 123
 124             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 125
 126             if ( matchesArtifactPattern( relativePath ) )
 127             {
 128                 ArtifactReference artifact = toArtifactReference( relativePath );
 129
 130                 // Test for related, groupId / artifactId / version must match.
 131                 if ( artifact.getGroupId().equals( reference.getGroupId() )
 132                     && artifact.getArtifactId().equals( reference.getArtifactId() )
 133                     && artifact.getVersion().equals( reference.getVersion() ) )
 134                 {
 135                     foundArtifacts.add( artifact );
 136                 }
 137             }
 138         }
 139
 140         return foundArtifacts;
 141     }
 142
 143     public String getRepoRoot()
 144     {
 145         return repository.getLocation();
 146     }
 147
 148     public ManagedRepositoryConfiguration getRepository()
 149     {
 150         return repository;
 151     }
 152
 153     /**
 154      * Gather the Available Versions (on disk) for a specific Project Reference, based on filesystem
 155      * information.
 156      *
 157      * @return the Set of available versions, based on the project reference.
 158      * @throws LayoutException
 159      * @throws LayoutException
 160      */
 161     public Set<String> getVersions( ProjectReference reference )
 162         throws ContentNotFoundException, LayoutException
 163     {
 164         String path = toMetadataPath( reference );
 165
 166         int idx = path.lastIndexOf( '/' );
 167         if ( idx > 0 )
 168         {
 169             path = path.substring( 0, idx );
 170         }
 171
 172         File repoDir = new File( repository.getLocation(), path );
 173
 174         if ( !repoDir.exists() )
 175         {
 176             throw new ContentNotFoundException( "Unable to get Versions on a non-existant directory: "
 177                 + repoDir.getAbsolutePath() );
 178         }
 179
 180         if ( !repoDir.isDirectory() )
 181         {
 182             throw new ContentNotFoundException( "Unable to get Versions on a non-directory: "
 183                 + repoDir.getAbsolutePath() );
 184         }
 185
 186         Set<String> foundVersions = new HashSet<String>();
 187         VersionedReference versionRef = new VersionedReference();
 188         versionRef.setGroupId( reference.getGroupId() );
 189         versionRef.setArtifactId( reference.getArtifactId() );
 190
 191         File repoFiles[] = repoDir.listFiles();
 192         for ( int i = 0; i < repoFiles.length; i++ )
 193         {
 194             if ( !repoFiles[i].isDirectory() )
 195             {
 196                 // Skip it. not a directory.
 197                 continue;
 198             }
 199
 200             // Test if dir has an artifact, which proves to us that it is a valid version directory.
 201             String version = repoFiles[i].getName();
 202             versionRef.setVersion( version );
 203
 204             if ( hasArtifact( versionRef ) )
 205             {
 206                 // Found an artifact, must be a valid version.
 207                 foundVersions.add( version );
 208             }
 209         }
 210
 211         return foundVersions;
 212     }
 213
 214     public Set<String> getVersions( VersionedReference reference )
 215         throws ContentNotFoundException, LayoutException
 216     {
 217         String path = toMetadataPath( reference );
 218
 219         int idx = path.lastIndexOf( '/' );
 220         if ( idx > 0 )
 221         {
 222             path = path.substring( 0, idx );
 223         }
 224
 225         File repoDir = new File( repository.getLocation(), path );
 226
 227         if ( !repoDir.exists() )
 228         {
 229             throw new ContentNotFoundException( "Unable to get versions on a non-existant directory: "
 230                 + repoDir.getAbsolutePath() );
 231         }
 232
 233         if ( !repoDir.isDirectory() )
 234         {
 235             throw new ContentNotFoundException( "Unable to get versions on a non-directory: "
 236                 + repoDir.getAbsolutePath() );
 237         }
 238
 239         Set<String> foundVersions = new HashSet<String>();
 240
 241         // First gather up the versions found as artifacts in the managed repository.
 242         File repoFiles[] = repoDir.listFiles();
 243         for ( int i = 0; i < repoFiles.length; i++ )
 244         {
 245             if ( repoFiles[i].isDirectory() )
 246             {
 247                 // Skip it. it's a directory.
 248                 continue;
 249             }
 250
 251             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 252
 253             if ( 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 initialize()
 304         throws InitializationException
 305     {
 306         this.artifactPatterns = new ArrayList<String>();
 307         initVariables();
 308     }
 309
 310     public void setRepository( ManagedRepositoryConfiguration repository )
 311     {
 312         this.repository = repository;
 313     }
 314
 315     /**
 316      * Convert a path to an artifact reference.
 317      *
 318      * @param path the path to convert. (relative or full location path)
 319      * @throws LayoutException if the path cannot be converted to an artifact reference.
 320      */
 321     @Override
 322     public ArtifactReference toArtifactReference( String path )
 323         throws LayoutException
 324     {
 325         if ( ( path != null ) && path.startsWith( repository.getLocation() ) )
 326         {
 327             return super.toArtifactReference( path.substring( repository.getLocation().length() ) );
 328         }
 329
 330         return super.toArtifactReference( path );
 331     }
 332
 333     public File toFile( ArtifactReference reference )
 334     {
 335         return new File( repository.getLocation(), toPath( reference ) );
 336     }
 337
 338     public File toFile( ArchivaArtifact reference )
 339     {
 340         return new File( repository.getLocation(), toPath( reference ) );
 341     }
 342
 343     /**
 344      * Get the first Artifact found in the provided VersionedReference location.
 345      *
 346      * @param managedRepository the repository to search within.
 347      * @param reference         the reference to the versioned reference to search within
 348      * @return the ArtifactReference to the first artifact located within the versioned reference. or null if
 349      *         no artifact was found within the versioned reference.
 350      * @throws IOException     if the versioned reference is invalid (example: doesn't exist, or isn't a directory)
 351      * @throws LayoutException
 352      */
 353     private ArtifactReference getFirstArtifact( VersionedReference reference )
 354         throws LayoutException, IOException
 355     {
 356         String path = toMetadataPath( reference );
 357
 358         int idx = path.lastIndexOf( '/' );
 359         if ( idx > 0 )
 360         {
 361             path = path.substring( 0, idx );
 362         }
 363
 364         File repoDir = new File( repository.getLocation(), path );
 365
 366         if ( !repoDir.exists() )
 367         {
 368             throw new IOException( "Unable to gather the list of snapshot versions on a non-existant directory: "
 369                 + repoDir.getAbsolutePath() );
 370         }
 371
 372         if ( !repoDir.isDirectory() )
 373         {
 374             throw new IOException( "Unable to gather the list of snapshot versions on a non-directory: "
 375                 + repoDir.getAbsolutePath() );
 376         }
 377
 378         File repoFiles[] = repoDir.listFiles();
 379         for ( int i = 0; i < repoFiles.length; i++ )
 380         {
 381             if ( repoFiles[i].isDirectory() )
 382             {
 383                 // Skip it. it's a directory.
 384                 continue;
 385             }
 386
 387             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 388
 389             if ( matchesArtifactPattern( relativePath ) )
 390             {
 391                 ArtifactReference artifact = toArtifactReference( relativePath );
 392
 393                 return artifact;
 394             }
 395         }
 396
 397         // No artifact was found.
 398         return null;
 399     }
 400
 401     private boolean hasArtifact( VersionedReference reference )
 402         throws LayoutException
 403     {
 404         try
 405         {
 406             return ( getFirstArtifact( reference ) != null );
 407         }
 408         catch ( IOException e )
 409         {
 410             return false;
 411         }
 412     }
 413
 414     private void initVariables()
 415     {
 416         synchronized ( this.artifactPatterns )
 417         {
 418             this.artifactPatterns.clear();
 419
 420             this.artifactPatterns.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 421         }
 422     }
 423
 424     private boolean matchesArtifactPattern( String relativePath )
 425     {
 426         // Correct the slash pattern.
 427         relativePath = relativePath.replace( '\\', '/' );
 428
 429         Iterator<String> it = this.artifactPatterns.iterator();
 430         while ( it.hasNext() )
 431         {
 432             String pattern = it.next();
 433
 434             if ( SelectorUtils.matchPath( pattern, relativePath, false ) )
 435             {
 436                 // Found match
 437                 return true;
 438             }
 439         }
 440
 441         // No match.
 442         return false;
 443     }
 444 }