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.matchesDefaultExclusions( relativePath ) )
 246             {
 247                 // Skip it, it's metadata or similar
 248                 continue;
 249             }
 250
 251             if ( filetypes.matchesArtifactPattern( relativePath ) )
 252             {
 253                 ArtifactReference artifact = toArtifactReference( relativePath );
 254
 255                 foundVersions.add( artifact.getVersion() );
 256             }
 257         }
 258
 259         return foundVersions;
 260     }
 261
 262     public boolean hasContent( ArtifactReference reference )
 263     {
 264         File artifactFile = toFile( reference );
 265         return artifactFile.exists() && artifactFile.isFile();
 266     }
 267
 268     public boolean hasContent( ProjectReference reference )
 269     {
 270         try
 271         {
 272             Set<String> versions = getVersions( reference );
 273             return !versions.isEmpty();
 274         }
 275         catch ( ContentNotFoundException e )
 276         {
 277             return false;
 278         }
 279         catch ( LayoutException e )
 280         {
 281             return false;
 282         }
 283     }
 284
 285     public boolean hasContent( VersionedReference reference )
 286     {
 287         try
 288         {
 289             return ( getFirstArtifact( reference ) != null );
 290         }
 291         catch ( IOException e )
 292         {
 293             return false;
 294         }
 295         catch ( LayoutException e )
 296         {
 297             return false;
 298         }
 299     }
 300
 301     public void setRepository( ManagedRepositoryConfiguration repository )
 302     {
 303         this.repository = repository;
 304     }
 305
 306     /**
 307      * Convert a path to an artifact reference.
 308      *
 309      * @param path the path to convert. (relative or full location path)
 310      * @throws LayoutException if the path cannot be converted to an artifact reference.
 311      */
 312     @Override
 313     public ArtifactReference toArtifactReference( String path )
 314         throws LayoutException
 315     {
 316         if ( ( path != null ) && path.startsWith( repository.getLocation() ) )
 317         {
 318             return super.toArtifactReference( path.substring( repository.getLocation().length() ) );
 319         }
 320
 321         return super.toArtifactReference( path );
 322     }
 323
 324     public File toFile( ArtifactReference reference )
 325     {
 326         return new File( repository.getLocation(), toPath( reference ) );
 327     }
 328
 329     public File toFile( ArchivaArtifact reference )
 330     {
 331         return new File( repository.getLocation(), toPath( reference ) );
 332     }
 333
 334     /**
 335      * Get the first Artifact found in the provided VersionedReference location.
 336      *
 337      * @param managedRepository the repository to search within.
 338      * @param reference         the reference to the versioned reference to search within
 339      * @return the ArtifactReference to the first artifact located within the versioned reference. or null if
 340      *         no artifact was found within the versioned reference.
 341      * @throws IOException     if the versioned reference is invalid (example: doesn't exist, or isn't a directory)
 342      * @throws LayoutException
 343      */
 344     private ArtifactReference getFirstArtifact( VersionedReference reference )
 345         throws LayoutException, IOException
 346     {
 347         String path = toMetadataPath( reference );
 348
 349         int idx = path.lastIndexOf( '/' );
 350         if ( idx > 0 )
 351         {
 352             path = path.substring( 0, idx );
 353         }
 354
 355         File repoDir = new File( repository.getLocation(), path );
 356
 357         if ( !repoDir.exists() )
 358         {
 359             throw new IOException( "Unable to gather the list of snapshot versions on a non-existant directory: "
 360                 + repoDir.getAbsolutePath() );
 361         }
 362
 363         if ( !repoDir.isDirectory() )
 364         {
 365             throw new IOException( "Unable to gather the list of snapshot versions on a non-directory: "
 366                 + repoDir.getAbsolutePath() );
 367         }
 368
 369         File repoFiles[] = repoDir.listFiles();
 370         for ( int i = 0; i < repoFiles.length; i++ )
 371         {
 372             if ( repoFiles[i].isDirectory() )
 373             {
 374                 // Skip it. it's a directory.
 375                 continue;
 376             }
 377
 378             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 379
 380             if ( filetypes.matchesArtifactPattern( relativePath ) )
 381             {
 382                 ArtifactReference artifact = toArtifactReference( relativePath );
 383
 384                 return artifact;
 385             }
 386         }
 387
 388         // No artifact was found.
 389         return null;
 390     }
 391
 392     private boolean hasArtifact( VersionedReference reference )
 393         throws LayoutException
 394     {
 395         try
 396         {
 397             return ( getFirstArtifact( reference ) != null );
 398         }
 399         catch ( IOException e )
 400         {
 401             return false;
 402         }
 403     }
 404 }