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