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.collections.CollectionUtils;
  23 import org.apache.commons.lang.StringUtils;
  24 import org.apache.maven.archiva.common.utils.PathUtil;
  25 import org.apache.maven.archiva.configuration.FileTypes;
  26 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
  27 import org.apache.maven.archiva.model.ArchivaArtifact;
  28 import org.apache.maven.archiva.model.ArtifactReference;
  29 import org.apache.maven.archiva.model.ProjectReference;
  30 import org.apache.maven.archiva.model.VersionedReference;
  31 import org.apache.maven.archiva.repository.ContentNotFoundException;
  32 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  33 import org.apache.maven.archiva.repository.layout.LayoutException;
  34 import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
  35 import org.codehaus.plexus.personality.plexus.lifecycle.phase.InitializationException;
  36 import org.codehaus.plexus.util.SelectorUtils;
  37
  38 import java.io.File;
  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  * ManagedLegacyRepositoryContent
  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="legacy"
  54  *      instantiation-strategy="per-lookup"
  55  */
  56 public class ManagedLegacyRepositoryContent
  57     extends AbstractLegacyRepositoryContent
  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         File groupDir = new File( repository.getLocation(), reference.getGroupId() );
  73
  74         if ( !groupDir.exists() )
  75         {
  76             throw new ContentNotFoundException( "Unable to get versions using a non-existant groupId directory: "
  77                 + groupDir.getAbsolutePath() );
  78         }
  79
  80         if ( !groupDir.isDirectory() )
  81         {
  82             throw new ContentNotFoundException( "Unable to get versions using a non-directory: "
  83                 + groupDir.getAbsolutePath() );
  84         }
  85
  86         // First gather up the versions found as artifacts in the managed repository.
  87         File typeDirs[] = groupDir.listFiles();
  88         for ( File typeDir : typeDirs )
  89         {
  90             if ( !typeDir.isDirectory() )
  91             {
  92                 // Skip it, we only care about directories.
  93                 continue;
  94             }
  95
  96             if ( !typeDir.getName().endsWith( "s" ) )
  97             {
  98                 // Skip it, we only care about directories that end in "s".
  99             }
 100
 101             deleteVersions( typeDir, reference );
 102         }
 103     }
 104
 105     private void deleteVersions( File typeDir, VersionedReference reference )
 106     {
 107         File repoFiles[] = typeDir.listFiles();
 108         for ( File repoFile : repoFiles )
 109         {
 110             if ( repoFile.isDirectory() )
 111             {
 112                 // Skip it. it's a directory.
 113                 continue;
 114             }
 115
 116             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFile );
 117
 118             if ( matchesArtifactPattern( relativePath ) )
 119             {
 120                 try
 121                 {
 122                     ArtifactReference artifact = toArtifactReference( relativePath );
 123                     if ( StringUtils.equals( artifact.getArtifactId(), reference.getArtifactId() )
 124                         && StringUtils.equals( artifact.getVersion(), reference.getVersion() ) )
 125                     {
 126                         repoFile.delete();
 127                         deleteSupportFiles( repoFile );
 128                     }
 129                 }
 130                 catch ( LayoutException e )
 131                 {
 132                     /* don't fail the process if there is a bad artifact within the directory. */
 133                 }
 134             }
 135         }
 136     }
 137
 138     private void deleteSupportFiles( File repoFile )
 139     {
 140         deleteSupportFile( repoFile, ".sha1" );
 141         deleteSupportFile( repoFile, ".md5" );
 142         deleteSupportFile( repoFile, ".asc" );
 143         deleteSupportFile( repoFile, ".gpg" );
 144     }
 145
 146     private void deleteSupportFile( File repoFile, String supportExtension )
 147     {
 148         File supportFile = new File( repoFile.getAbsolutePath() + supportExtension );
 149         if ( supportFile.exists() && supportFile.isFile() )
 150         {
 151             supportFile.delete();
 152         }
 153     }
 154
 155     public String getId()
 156     {
 157         return repository.getId();
 158     }
 159
 160     public Set<ArtifactReference> getRelatedArtifacts( ArtifactReference reference )
 161         throws ContentNotFoundException, LayoutException
 162     {
 163         File artifactFile = toFile( reference );
 164         File repoDir = artifactFile.getParentFile();
 165
 166         if ( !repoDir.exists() )
 167         {
 168             throw new ContentNotFoundException( "Unable to get related artifacts using a non-existant directory: "
 169                 + repoDir.getAbsolutePath() );
 170         }
 171
 172         if ( !repoDir.isDirectory() )
 173         {
 174             throw new ContentNotFoundException( "Unable to get related artifacts using a non-directory: "
 175                 + repoDir.getAbsolutePath() );
 176         }
 177
 178         Set<ArtifactReference> foundArtifacts = new HashSet<ArtifactReference>();
 179
 180         // First gather up the versions found as artifacts in the managed repository.
 181         File projectParentDir = repoDir.getParentFile();
 182         File typeDirs[] = projectParentDir.listFiles();
 183         for ( File typeDir : typeDirs )
 184         {
 185             if ( !typeDir.isDirectory() )
 186             {
 187                 // Skip it, we only care about directories.
 188                 continue;
 189             }
 190
 191             if ( !typeDir.getName().endsWith( "s" ) )
 192             {
 193                 // Skip it, we only care about directories that end in "s".
 194             }
 195
 196             getRelatedArtifacts( typeDir, reference, foundArtifacts );
 197         }
 198
 199         return foundArtifacts;
 200     }
 201
 202     public String getRepoRoot()
 203     {
 204         return repository.getLocation();
 205     }
 206
 207     public ManagedRepositoryConfiguration getRepository()
 208     {
 209         return repository;
 210     }
 211
 212     public Set<String> getVersions( ProjectReference reference )
 213         throws ContentNotFoundException
 214     {
 215         File groupDir = new File( repository.getLocation(), reference.getGroupId() );
 216
 217         if ( !groupDir.exists() )
 218         {
 219             throw new ContentNotFoundException( "Unable to get versions using a non-existant groupId directory: "
 220                 + groupDir.getAbsolutePath() );
 221         }
 222
 223         if ( !groupDir.isDirectory() )
 224         {
 225             throw new ContentNotFoundException( "Unable to get versions using a non-directory: "
 226                 + groupDir.getAbsolutePath() );
 227         }
 228
 229         Set<String> foundVersions = new HashSet<String>();
 230
 231         // First gather up the versions found as artifacts in the managed repository.
 232         File typeDirs[] = groupDir.listFiles();
 233         for ( File typeDir : typeDirs )
 234         {
 235             if ( !typeDir.isDirectory() )
 236             {
 237                 // Skip it, we only care about directories.
 238                 continue;
 239             }
 240
 241             if ( !typeDir.getName().endsWith( "s" ) )
 242             {
 243                 // Skip it, we only care about directories that end in "s".
 244             }
 245
 246             getProjectVersions( typeDir, reference, foundVersions );
 247         }
 248
 249         return foundVersions;
 250     }
 251
 252     public Set<String> getVersions( VersionedReference reference )
 253         throws ContentNotFoundException
 254     {
 255         File groupDir = new File( repository.getLocation(), reference.getGroupId() );
 256
 257         if ( !groupDir.exists() )
 258         {
 259             throw new ContentNotFoundException( "Unable to get versions using a non-existant groupId directory: "
 260                 + groupDir.getAbsolutePath() );
 261         }
 262
 263         if ( !groupDir.isDirectory() )
 264         {
 265             throw new ContentNotFoundException( "Unable to get versions using a non-directory: "
 266                 + groupDir.getAbsolutePath() );
 267         }
 268
 269         Set<String> foundVersions = new HashSet<String>();
 270
 271         // First gather up the versions found as artifacts in the managed repository.
 272         File typeDirs[] = groupDir.listFiles();
 273         for ( File typeDir : typeDirs )
 274         {
 275             if ( !typeDir.isDirectory() )
 276             {
 277                 // Skip it, we only care about directories.
 278                 continue;
 279             }
 280
 281             if ( !typeDir.getName().endsWith( "s" ) )
 282             {
 283                 // Skip it, we only care about directories that end in "s".
 284             }
 285
 286             getVersionedVersions( typeDir, reference, foundVersions );
 287         }
 288
 289         return foundVersions;
 290     }
 291
 292     public boolean hasContent( ArtifactReference reference )
 293     {
 294         File artifactFile = toFile( reference );
 295         return artifactFile.exists() && artifactFile.isFile();
 296     }
 297
 298     public boolean hasContent( ProjectReference reference )
 299     {
 300         try
 301         {
 302             Set<String> versions = getVersions( reference );
 303             return CollectionUtils.isNotEmpty( versions );
 304         }
 305         catch ( ContentNotFoundException e )
 306         {
 307             return false;
 308         }
 309     }
 310
 311     public boolean hasContent( VersionedReference reference )
 312     {
 313         try
 314         {
 315             Set<String> versions = getVersions( reference );
 316             return CollectionUtils.isNotEmpty( versions );
 317         }
 318         catch ( ContentNotFoundException e )
 319         {
 320             return false;
 321         }
 322     }
 323
 324     public void initialize()
 325         throws InitializationException
 326     {
 327         this.artifactPatterns = new ArrayList<String>();
 328         initVariables();
 329     }
 330
 331     public void setRepository( ManagedRepositoryConfiguration repository )
 332     {
 333         this.repository = repository;
 334     }
 335
 336     /**
 337      * Convert a path to an artifact reference.
 338      *
 339      * @param path the path to convert. (relative or full location path)
 340      * @throws LayoutException if the path cannot be converted to an artifact reference.
 341      */
 342     @Override
 343     public ArtifactReference toArtifactReference( String path )
 344         throws LayoutException
 345     {
 346         if ( ( path != null ) && path.startsWith( repository.getLocation() ) )
 347         {
 348             return super.toArtifactReference( path.substring( repository.getLocation().length() ) );
 349         }
 350
 351         return super.toArtifactReference( path );
 352     }
 353
 354     public File toFile( ArchivaArtifact reference )
 355     {
 356         return new File( repository.getLocation(), toPath( reference ) );
 357     }
 358
 359     public File toFile( ArtifactReference reference )
 360     {
 361         return new File( repository.getLocation(), toPath( reference ) );
 362     }
 363
 364     public String toMetadataPath( ProjectReference reference )
 365     {
 366         // No metadata present in legacy repository.
 367         return null;
 368     }
 369
 370     public String toMetadataPath( VersionedReference reference )
 371     {
 372         // No metadata present in legacy repository.
 373         return null;
 374     }
 375
 376     private void getProjectVersions( File typeDir, ProjectReference reference, Set<String> foundVersions )
 377     {
 378         File repoFiles[] = typeDir.listFiles();
 379         for ( File repoFile : repoFiles )
 380         {
 381             if ( repoFile.isDirectory() )
 382             {
 383                 // Skip it. it's a directory.
 384                 continue;
 385             }
 386
 387             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFile );
 388
 389             if ( matchesArtifactPattern( relativePath ) )
 390             {
 391                 try
 392                 {
 393                     ArtifactReference artifact = toArtifactReference( relativePath );
 394                     if ( StringUtils.equals( artifact.getArtifactId(), reference.getArtifactId() ) )
 395                     {
 396                         foundVersions.add( artifact.getVersion() );
 397                     }
 398                 }
 399                 catch ( LayoutException e )
 400                 {
 401                     /* don't fail the process if there is a bad artifact within the directory. */
 402                 }
 403             }
 404         }
 405     }
 406
 407     private void getRelatedArtifacts( File typeDir, ArtifactReference reference, Set<ArtifactReference> foundArtifacts )
 408     {
 409         File repoFiles[] = typeDir.listFiles();
 410         for ( int i = 0; i < repoFiles.length; i++ )
 411         {
 412             if ( repoFiles[i].isDirectory() )
 413             {
 414                 // Skip it. it's a directory.
 415                 continue;
 416             }
 417
 418             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 419
 420             if ( matchesArtifactPattern( relativePath ) )
 421             {
 422                 try
 423                 {
 424                     ArtifactReference artifact = toArtifactReference( relativePath );
 425                     if ( StringUtils.equals( artifact.getArtifactId(), reference.getArtifactId() )
 426                         && artifact.getVersion().startsWith( reference.getVersion() ) )
 427                     {
 428                         foundArtifacts.add( artifact );
 429                     }
 430                 }
 431                 catch ( LayoutException e )
 432                 {
 433                     /* don't fail the process if there is a bad artifact within the directory. */
 434                 }
 435             }
 436         }
 437     }
 438
 439     private void getVersionedVersions( File typeDir, VersionedReference reference, Set<String> foundVersions )
 440     {
 441         File repoFiles[] = typeDir.listFiles();
 442         for ( int i = 0; i < repoFiles.length; i++ )
 443         {
 444             if ( repoFiles[i].isDirectory() )
 445             {
 446                 // Skip it. it's a directory.
 447                 continue;
 448             }
 449
 450             String relativePath = PathUtil.getRelative( repository.getLocation(), repoFiles[i] );
 451
 452             if ( matchesArtifactPattern( relativePath ) )
 453             {
 454                 try
 455                 {
 456                     ArtifactReference artifact = toArtifactReference( relativePath );
 457                     if ( StringUtils.equals( artifact.getArtifactId(), reference.getArtifactId() )
 458                         && artifact.getVersion().startsWith( reference.getVersion() ) )
 459                     {
 460                         foundVersions.add( artifact.getVersion() );
 461                     }
 462                 }
 463                 catch ( LayoutException e )
 464                 {
 465                     /* don't fail the process if there is a bad artifact within the directory. */
 466                 }
 467             }
 468         }
 469     }
 470
 471     private void initVariables()
 472     {
 473         synchronized ( this.artifactPatterns )
 474         {
 475             this.artifactPatterns.clear();
 476
 477             this.artifactPatterns.addAll( filetypes.getFileTypePatterns( FileTypes.ARTIFACTS ) );
 478         }
 479     }
 480
 481     private boolean matchesArtifactPattern( String relativePath )
 482     {
 483         // Correct the slash pattern.
 484         relativePath = relativePath.replace( '\\', '/' );
 485
 486         Iterator<String> it = this.artifactPatterns.iterator();
 487         while ( it.hasNext() )
 488         {
 489             String pattern = it.next();
 490
 491             if ( SelectorUtils.matchPath( pattern, relativePath, false ) )
 492             {
 493                 // Found match
 494                 return true;
 495             }
 496         }
 497
 498         // No match.
 499         return false;
 500     }
 501 }