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