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

   1 package org.apache.archiva.consumers.lucene;
   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.configuration.ManagedRepositoryConfiguration;
  23 import org.apache.maven.archiva.consumers.AbstractMonitoredConsumer;
  24 import org.apache.maven.archiva.consumers.ConsumerException;
  25 import org.apache.maven.archiva.database.updater.DatabaseCleanupConsumer;
  26 import org.apache.maven.archiva.model.ArchivaArtifact;
  27 import org.apache.maven.archiva.repository.ManagedRepositoryContent;
  28 import org.apache.maven.archiva.repository.RepositoryContentFactory;
  29 import org.apache.maven.archiva.repository.RepositoryException;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32 import org.sonatype.nexus.index.ArtifactContext;
  33 import org.sonatype.nexus.index.ArtifactContextProducer;
  34 import org.sonatype.nexus.index.DefaultArtifactContextProducer;
  35 import org.sonatype.nexus.index.NexusIndexer;
  36 import org.sonatype.nexus.index.context.DefaultIndexingContext;
  37 import org.sonatype.nexus.index.context.IndexingContext;
  38 import org.sonatype.nexus.index.context.UnsupportedExistingLuceneIndexException;
  39 import org.sonatype.nexus.index.IndexerEngine;
  40
  41 import java.io.File;
  42 import java.io.IOException;
  43 import java.util.List;
  44
  45 /**
  46  * LuceneCleanupRemoveIndexedConsumer
  47  *
  48  * @version $Id$
  49  */
  50 public class LuceneCleanupRemoveIndexedConsumer
  51     extends AbstractMonitoredConsumer
  52     implements DatabaseCleanupConsumer
  53 {
  54     private static final Logger log = LoggerFactory.getLogger( LuceneCleanupRemoveIndexedConsumer.class );
  55
  56     private RepositoryContentFactory repoFactory;
  57
  58     private ArtifactContextProducer artifactContextProducer;
  59
  60     private IndexingContext context;
  61
  62     private IndexerEngine indexerEngine;
  63
  64     //TODO - deng - use indexerEngine to remove documents instead of directly using the IndexingContext!
  65
  66     public LuceneCleanupRemoveIndexedConsumer( RepositoryContentFactory repoFactory, IndexerEngine indexerEngine )
  67     {
  68         this.repoFactory = repoFactory;
  69         this.indexerEngine = indexerEngine;
  70         this.artifactContextProducer = new DefaultArtifactContextProducer();
  71     }
  72
  73     public void beginScan()
  74     {
  75     }
  76
  77     public void completeScan()
  78     {
  79         /*synchronized( indexerEngine )
  80         {
  81             try
  82             {
  83                 //context.getIndexWriter().close();
  84
  85                 //indexerEngine.endIndexing( context );
  86                 //indexer.removeIndexingContext( context, false );
  87             }
  88             catch ( IOException e )
  89             {
  90                 log.error( e.getMessage() );
  91             }
  92         }        */
  93     }
  94
  95     public List<String> getIncludedTypes()
  96     {
  97         // TODO Auto-generated method stub
  98         return null;
  99     }
 100
 101     public void processArchivaArtifact( ArchivaArtifact artifact )
 102         throws ConsumerException
 103     {
 104         //synchronized( context )
 105         //{
 106             // TODO - deng - block this if there is the nexus indexer consumer is executing?
 107             ManagedRepositoryContent repoContent = null;
 108
 109             try
 110             {
 111                repoContent =
 112                     repoFactory.getManagedRepositoryContent( artifact.getModel().getRepositoryId() );
 113             }
 114             catch ( RepositoryException e )
 115             {
 116                 throw new ConsumerException( "Can't run index cleanup consumer: " + e.getMessage() );
 117             }
 118
 119             ManagedRepositoryConfiguration repository = repoContent.getRepository();
 120             String indexDir = repository.getIndexDir();
 121             File managedRepository = new File( repository.getLocation() );
 122             File indexDirectory = null;
 123
 124             if ( indexDir != null && !"".equals( indexDir ) )
 125             {
 126                 indexDirectory = new File( repository.getIndexDir() );
 127             }
 128             else
 129             {
 130                 indexDirectory = new File( managedRepository, ".indexer" );
 131             }
 132
 133             try
 134             {
 135                 context =
 136                     new DefaultIndexingContext( repository.getId(), repository.getId(), managedRepository,
 137                                                 indexDirectory, null, null, NexusIndexer.FULL_INDEX, false );
 138                 //context =
 139                 //    indexer.addIndexingContext( repository.getId(), repository.getId(), managedRepository,
 140                 //                                indexDirectory, null, null, NexusIndexer.FULL_INDEX );
 141                 context.setSearchable( repository.isScanned() );
 142             }
 143             catch ( UnsupportedExistingLuceneIndexException e )
 144             {
 145                 log.warn( "Unsupported index format.", e );
 146                 return;
 147             }
 148             catch ( IOException e )
 149             {
 150                 log.warn( "Unable to open index at " + indexDirectory.getAbsoluteFile(), e );
 151                 return;
 152             }
 153
 154             try
 155             {
 156                 File artifactFile = new File( repoContent.getRepoRoot(), repoContent.toPath( artifact ) );
 157
 158                 if ( !artifactFile.exists() )
 159                 {
 160                     ArtifactContext artifactContext =
 161                         artifactContextProducer.getArtifactContext( context, artifactFile );
 162
 163                     if ( artifactContext != null )
 164                     {
 165                         //indexerEngine.remove( context, artifactContext );
 166
 167                         indexerEngine.remove( context, artifactContext );
 168
 169                         context.close( false );
 170                         // hack for deleting documents - indexer engine's remove(...) isn't working for me
 171                         //removeDocuments( artifactContext );
 172                     }
 173                 }
 174             }
 175             catch ( IOException e )
 176             {
 177                 log.error( "Unable to open index at " + indexDirectory.getAbsoluteFile(), e );
 178             }
 179        // }
 180     }
 181
 182    /* private void removeDocuments( ArtifactContext ac )
 183         throws IOException
 184     {
 185         synchronized( indexerEngine )
 186         {
 187             IndexWriter w = context.getIndexWriter();
 188
 189             ArtifactInfo ai = ac.getArtifactInfo();
 190             String uinfo = AbstractIndexCreator.getGAV( ai.groupId, ai.artifactId, ai.version, ai.classifier, ai.packaging );
 191
 192             Document doc = new Document();
 193             doc.add( new Field( ArtifactInfo.DELETED, uinfo, Field.Store.YES, Field.Index.NO ) );
 194             doc.add( new Field( ArtifactInfo.LAST_MODIFIED, Long.toString( System.currentTimeMillis() ), Field.Store.YES,
 195                                 Field.Index.NO ) );
 196
 197             w.addDocument( doc );
 198
 199             w.deleteDocuments( new Term( ArtifactInfo.UINFO, uinfo ) );
 200
 201             w.commit();
 202
 203             context.updateTimestamp();
 204         }
 205     }*/
 206
 207     public String getDescription()
 208     {
 209         return "Remove indexed content if not present on filesystem.";
 210     }
 211
 212     public String getId()
 213     {
 214         return "not-present-remove-indexed";
 215     }
 216
 217     public boolean isPermanent()
 218     {
 219         return false;
 220     }
 221
 222     public void setRepositoryContentFactory( RepositoryContentFactory repoFactory )
 223     {
 224         this.repoFactory = repoFactory;
 225     }
 226
 227     public void setArtifactContextProducer( ArtifactContextProducer artifactContextProducer )
 228     {
 229         this.artifactContextProducer = artifactContextProducer;
 230     }
 231 }