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

   1 package org.apache.maven.archiva.consumers.core.repository;
   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.maven.archiva.database.ArchivaDatabaseException;
  23 import org.apache.maven.archiva.database.ArtifactDAO;
  24 import org.apache.maven.archiva.indexer.RepositoryContentIndex;
  25 import org.apache.maven.archiva.indexer.RepositoryIndexException;
  26 import org.apache.maven.archiva.indexer.bytecode.BytecodeRecord;
  27 import org.apache.maven.archiva.indexer.filecontent.FileContentRecord;
  28 import org.apache.maven.archiva.indexer.hashcodes.HashcodesRecord;
  29 import org.apache.maven.archiva.indexer.lucene.LuceneRepositoryContentRecord;
  30 import org.apache.maven.archiva.model.ArchivaArtifact;
  31 import org.apache.maven.archiva.model.ArtifactReference;
  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.io.FilenameFilter;
  37 import java.util.ArrayList;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41
  42 /**
  43  * Base class for all repository purge tasks.
  44  *
  45  * @author <a href="mailto:oching@apache.org">Maria Odea Ching</a>
  46  */
  47 public abstract class AbstractRepositoryPurge
  48     implements RepositoryPurge
  49 {
  50     protected ManagedRepositoryContent repository;
  51
  52     protected ArtifactDAO artifactDao;
  53
  54     private Map<String, RepositoryContentIndex> indices;
  55
  56     public AbstractRepositoryPurge( ManagedRepositoryContent repository, ArtifactDAO artifactDao,
  57                                     Map<String, RepositoryContentIndex> indices )
  58     {
  59         this.repository = repository;
  60         this.artifactDao = artifactDao;
  61         this.indices = indices;
  62     }
  63
  64     /**
  65      * Get all files from the directory that matches the specified filename.
  66      *
  67      * @param dir the directory to be scanned
  68      * @param filename the filename to be matched
  69      * @return
  70      */
  71     protected File[] getFiles( File dir, String filename )
  72     {
  73         FilenameFilter filter = new ArtifactFilenameFilter( filename );
  74
  75         File[] files = dir.listFiles( filter );
  76
  77         return files;
  78     }
  79
  80     protected String toRelativePath( File artifactFile )
  81     {
  82         String artifactPath = artifactFile.getAbsolutePath();
  83         if ( artifactPath.startsWith( repository.getRepoRoot() ) )
  84         {
  85             artifactPath = artifactPath.substring( repository.getRepoRoot().length() );
  86         }
  87
  88         return artifactPath;
  89     }
  90
  91     /**
  92      * Purge the repo. Update db and index of removed artifacts.
  93      *
  94      * @param artifactFiles
  95      * @throws RepositoryIndexException
  96      */
  97     protected void purge( Set<ArtifactReference> references )
  98     {
  99         List<LuceneRepositoryContentRecord> fileContentRecords = new ArrayList<LuceneRepositoryContentRecord>();
 100         List<LuceneRepositoryContentRecord> hashcodeRecords = new ArrayList<LuceneRepositoryContentRecord>();
 101         List<LuceneRepositoryContentRecord> bytecodeRecords = new ArrayList<LuceneRepositoryContentRecord>();
 102
 103         for ( ArtifactReference reference : references )
 104         {
 105             File artifactFile = repository.toFile( reference );
 106
 107             ArchivaArtifact artifact =
 108                 new ArchivaArtifact( reference.getGroupId(), reference.getArtifactId(), reference.getVersion(),
 109                                      reference.getClassifier(), reference.getType() );
 110
 111             FileContentRecord fileContentRecord = new FileContentRecord();
 112             fileContentRecord.setFilename( repository.toPath( artifact ) );
 113             fileContentRecords.add( fileContentRecord );
 114
 115             HashcodesRecord hashcodesRecord = new HashcodesRecord();
 116             hashcodesRecord.setArtifact( artifact );
 117             hashcodeRecords.add( hashcodesRecord );
 118
 119             BytecodeRecord bytecodeRecord = new BytecodeRecord();
 120             bytecodeRecord.setArtifact( artifact );
 121             bytecodeRecords.add( bytecodeRecord );
 122
 123             // TODO: this needs to be logged
 124             artifactFile.delete();
 125             purgeSupportFiles( artifactFile );
 126
 127             // intended to be swallowed
 128             // continue updating the database for all artifacts
 129             try
 130             {
 131                 String artifactPath = toRelativePath( artifactFile );
 132                 updateDatabase( artifactPath );
 133             }
 134             catch ( ArchivaDatabaseException ae )
 135             {
 136                 // TODO: determine logging to be used
 137             }
 138             catch ( LayoutException le )
 139             {
 140                 // Ignore
 141             }
 142         }
 143
 144         try
 145         {
 146             updateIndices( fileContentRecords, hashcodeRecords, bytecodeRecords );
 147         }
 148         catch ( RepositoryIndexException e )
 149         {
 150             // Ignore
 151         }
 152     }
 153
 154     /**
 155      * <p>
 156      * This find support files for the artifactFile and deletes them.
 157      * </p>
 158      * <p>
 159      * Support Files are things like ".sha1", ".md5", ".asc", etc.
 160      * </p>
 161      *
 162      * @param artifactFile the file to base off of.
 163      */
 164     private void purgeSupportFiles( File artifactFile )
 165     {
 166         File parentDir = artifactFile.getParentFile();
 167
 168         if ( !parentDir.exists() )
 169         {
 170             return;
 171         }
 172
 173         FilenameFilter filter = new ArtifactFilenameFilter( artifactFile.getName() );
 174
 175         File[] files = parentDir.listFiles( filter );
 176
 177         for ( File file : files )
 178         {
 179             if ( file.exists() && file.isFile() )
 180             {
 181                 file.delete();
 182                 // TODO: log that it was deleted
 183             }
 184         }
 185     }
 186
 187     private void updateDatabase( String path )
 188         throws ArchivaDatabaseException, LayoutException
 189     {
 190         ArtifactReference artifact = repository.toArtifactReference( path );
 191         ArchivaArtifact queriedArtifact =
 192             artifactDao.getArtifact( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(),
 193                                      artifact.getClassifier(), artifact.getType() );
 194
 195         artifactDao.deleteArtifact( queriedArtifact );
 196
 197         // TODO [MRM-37]: re-run the database consumers to clean up
 198     }
 199
 200     private void updateIndices( List<LuceneRepositoryContentRecord> fileContentRecords,
 201                                 List<LuceneRepositoryContentRecord> hashcodeRecords,
 202                                 List<LuceneRepositoryContentRecord> bytecodeRecords )
 203         throws RepositoryIndexException
 204     {
 205         RepositoryContentIndex index = indices.get( "filecontent" );
 206         index.deleteRecords( fileContentRecords );
 207
 208         index = indices.get( "hashcodes" );
 209         index.deleteRecords( hashcodeRecords );
 210
 211         index = indices.get( "bytecode" );
 212         index.deleteRecords( bytecodeRecords );
 213     }
 214 }