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