package org.apache.archiva.scheduler.indexing;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the Li
* cense is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import org.apache.archiva.admin.model.RepositoryAdminException;
import org.apache.archiva.admin.model.beans.ManagedRepository;
import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin;
import org.apache.archiva.common.plexusbridge.PlexusSisuBridge;
import org.apache.archiva.common.plexusbridge.PlexusSisuBridgeException;
import org.apache.archiva.redback.components.taskqueue.Task;
import org.apache.archiva.redback.components.taskqueue.execution.TaskExecutionException;
import org.apache.archiva.redback.components.taskqueue.execution.TaskExecutor;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.maven.index.ArtifactContext;
import org.apache.maven.index.ArtifactContextProducer;
import org.apache.maven.index.FlatSearchRequest;
import org.apache.maven.index.FlatSearchResponse;
import org.apache.maven.index.MAVEN;
import org.apache.maven.index.NexusIndexer;
import org.apache.maven.index.context.IndexingContext;
import org.apache.maven.index.expr.SourcedSearchExpression;
import org.apache.maven.index.packer.IndexPacker;
import org.apache.maven.index.packer.IndexPackingRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.io.File;
import java.io.IOException;
/**
* ArchivaIndexingTaskExecutor Executes all indexing tasks. Adding, updating and removing artifacts from the index are
* all performed by this executor. Add and update artifact in index tasks are added in the indexing task queue by the
* NexusIndexerConsumer while remove artifact from index tasks are added by the LuceneCleanupRemoveIndexedConsumer.
*/
@Service ( "taskExecutor#indexing" )
public class ArchivaIndexingTaskExecutor
implements TaskExecutor
{
private Logger log = LoggerFactory.getLogger( ArchivaIndexingTaskExecutor.class );
private IndexPacker indexPacker;
private ArtifactContextProducer artifactContextProducer;
@Inject
private PlexusSisuBridge plexusSisuBridge;
@Inject
private ManagedRepositoryAdmin managedRepositoryAdmin;
private NexusIndexer nexusIndexer;
@PostConstruct
public void initialize()
throws PlexusSisuBridgeException
{
log.info( "Initialized {}", this.getClass().getName() );
artifactContextProducer = plexusSisuBridge.lookup( ArtifactContextProducer.class );
indexPacker = plexusSisuBridge.lookup( IndexPacker.class, "default" );
nexusIndexer = plexusSisuBridge.lookup( NexusIndexer.class );
}
/**
* depending on current {@link Task} you have.
* If {@link org.apache.archiva.scheduler.indexing.ArtifactIndexingTask.Action#FINISH} && isExecuteOnEntireRepo:
* repository will be scanned.
*
* @param task
* @throws TaskExecutionException
*/
@Override
public void executeTask( Task task )
throws TaskExecutionException
{
ArtifactIndexingTask indexingTask = (ArtifactIndexingTask) task;
ManagedRepository repository = indexingTask.getRepository();
IndexingContext context = indexingTask.getContext();
if ( ArtifactIndexingTask.Action.FINISH.equals( indexingTask.getAction() )
&& indexingTask.isExecuteOnEntireRepo() )
{
try
{
long start = System.currentTimeMillis();
nexusIndexer.scan( context, null, indexingTask.isOnlyUpdate() );
long end = System.currentTimeMillis();
log.info( "indexed maven repository: {}, onlyUpdate: {}, time {} ms", repository.getId(),
indexingTask.isOnlyUpdate(), ( end - start ) );
}
catch ( IOException e )
{
throw new TaskExecutionException( "Error scan repository " + repository, e );
}
log.debug( "Finishing indexing task on repo: {}", repository.getId() );
finishIndexingTask( indexingTask, repository, context );
}
else
{
// create context if not a repo scan request
if ( !indexingTask.isExecuteOnEntireRepo() )
{
try
{
log.debug( "Creating indexing context on resource: {}", ( indexingTask.getResourceFile() == null
? "none"
: indexingTask.getResourceFile().getPath() ) );
context = managedRepositoryAdmin.createIndexContext( repository );
}
catch ( RepositoryAdminException e )
{
log.error( "Error occurred while creating context: " + e.getMessage() );
throw new TaskExecutionException( "Error occurred while creating context: " + e.getMessage(), e );
}
}
if ( context == null || context.getIndexDirectory() == null )
{
throw new TaskExecutionException( "Trying to index an artifact but the context is already closed" );
}
try
{
File artifactFile = indexingTask.getResourceFile();
if ( artifactFile == null )
{
log.debug( "no artifact pass in indexing task so skip it" );
}
else
{
ArtifactContext ac = artifactContextProducer.getArtifactContext( context, artifactFile );
if ( ac != null )
{
// MRM-1779 pom must be indexed too
// TODO make that configurable?
if ( artifactFile.getPath().endsWith( ".pom" ) )
{
ac.getArtifactInfo().fextension = "pom";
ac.getArtifactInfo().packaging = "pom";
ac.getArtifactInfo().classifier = "pom";
}
if ( indexingTask.getAction().equals( ArtifactIndexingTask.Action.ADD ) )
{
//IndexSearcher s = context.getIndexSearcher();
//String uinfo = ac.getArtifactInfo().getUinfo();
//TopDocs d = s.search( new TermQuery( new Term( ArtifactInfo.UINFO, uinfo ) ), 1 );
BooleanQuery q = new BooleanQuery();
q.add( nexusIndexer.constructQuery( MAVEN.GROUP_ID, new SourcedSearchExpression(
ac.getArtifactInfo().groupId ) ), BooleanClause.Occur.MUST );
q.add( nexusIndexer.constructQuery( MAVEN.ARTIFACT_ID, new SourcedSearchExpression(
ac.getArtifactInfo().artifactId ) ), BooleanClause.Occur.MUST );
q.add( nexusIndexer.constructQuery( MAVEN.VERSION, new SourcedSearchExpression(
ac.getArtifactInfo().version ) ), BooleanClause.Occur.MUST );
if ( ac.getArtifactInfo().classifier != null )
{
q.add( nexusIndexer.constructQuery( MAVEN.CLASSIFIER, new SourcedSearchExpression(
ac.getArtifactInfo().classifier ) ), BooleanClause.Occur.MUST );
}
if ( ac.getArtifactInfo().packaging != null )
{
q.add( nexusIndexer.constructQuery( MAVEN.PACKAGING, new SourcedSearchExpression(
ac.getArtifactInfo().packaging ) ), BooleanClause.Occur.MUST );
}
FlatSearchRequest flatSearchRequest = new FlatSearchRequest( q, context );
FlatSearchResponse flatSearchResponse = nexusIndexer.searchFlat( flatSearchRequest );
if ( flatSearchResponse.getResults().isEmpty() )
{
log.debug( "Adding artifact '{}' to index..", ac.getArtifactInfo() );
nexusIndexer.addArtifactToIndex( ac, context );
}
else
{
log.debug( "Updating artifact '{}' in index..", ac.getArtifactInfo() );
// TODO check if update exists !!
nexusIndexer.deleteArtifactFromIndex( ac, context );
nexusIndexer.addArtifactToIndex( ac, context );
}
context.updateTimestamp();
context.commit();
}
else
{
log.debug( "Removing artifact '{}' from index..", ac.getArtifactInfo() );
nexusIndexer.deleteArtifactFromIndex( ac, context );
}
}
}
// close the context if not a repo scan request
if ( !indexingTask.isExecuteOnEntireRepo() )
{
log.debug( "Finishing indexing task on resource file : {}", indexingTask.getResourceFile() != null
? indexingTask.getResourceFile().getPath()
: " none " );
finishIndexingTask( indexingTask, repository, context );
}
}
catch ( IOException e )
{
log.error( "Error occurred while executing indexing task '" + indexingTask + "': " + e.getMessage(),
e );
throw new TaskExecutionException( "Error occurred while executing indexing task '" + indexingTask + "'",
e );
}
}
}
private void finishIndexingTask( ArtifactIndexingTask indexingTask, ManagedRepository repository,
IndexingContext context )
throws TaskExecutionException
{
try
{
context.optimize();
if ( !repository.isSkipPackedIndexCreation() )
{
IndexPackingRequest request = new IndexPackingRequest( context, context.getIndexDirectoryFile() );
indexPacker.packIndex( request );
context.updateTimestamp( true );
log.debug( "Index file packaged at '{}'.", context.getIndexDirectoryFile() );
}
else
{
log.debug( "skip packed index creation" );
}
}
catch ( IOException e )
{
log.error( "Error occurred while executing indexing task '" + indexingTask + "': " + e.getMessage() );
throw new TaskExecutionException( "Error occurred while executing indexing task '" + indexingTask + "'",
e );
}
}
public void setIndexPacker( IndexPacker indexPacker )
{
this.indexPacker = indexPacker;
}
public PlexusSisuBridge getPlexusSisuBridge()
{
return plexusSisuBridge;
}
public void setPlexusSisuBridge( PlexusSisuBridge plexusSisuBridge )
{
this.plexusSisuBridge = plexusSisuBridge;
}
}