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