source.dussan.org Git - archiva.git/blob

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