indexer-examples/indexer-examples-spring/src/main/java/org/apache/maven/indexer/examples/indexing/RepositoryIndexer.java

package org.apache.maven.indexer.examples.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 License 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.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.util.Version;
import org.apache.maven.index.ArtifactContext;
import org.apache.maven.index.ArtifactInfo;
import org.apache.maven.index.ArtifactScanningListener;
import org.apache.maven.index.FlatSearchRequest;
import org.apache.maven.index.FlatSearchResponse;
import org.apache.maven.index.Indexer;
import org.apache.maven.index.MAVEN;
import org.apache.maven.index.Scanner;
import org.apache.maven.index.ScanningRequest;
import org.apache.maven.index.ScanningResult;
import org.apache.maven.index.context.IndexCreator;
import org.apache.maven.index.context.IndexingContext;
import org.apache.maven.index.expr.SourcedSearchExpression;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import static java.util.Arrays.asList;
import static org.apache.lucene.search.BooleanClause.Occur.MUST;

/**
 * This class provides means to index and search for artifacts in a repository on the file system.
 *
 * @author mtodorov
 */
public class RepositoryIndexer
{

    private static final Logger LOGGER = LoggerFactory.getLogger( RepositoryIndexer.class );

    private static final String[] luceneFields = new String[]{ "g", "a", "v", "p", "c" };

    private static final WhitespaceAnalyzer luceneAnalyzer = new WhitespaceAnalyzer( );

    private Indexer indexer;

    private Scanner scanner;

    private List<IndexCreator> indexers;

    private IndexingContext indexingContext;

    private String repositoryId;

    private File repositoryBasedir;

    private File indexDir;


    public RepositoryIndexer()
    {
        // no op
    }

    public void close()
        throws IOException
    {
        indexer.closeIndexingContext( indexingContext, false );
    }

    public void close( boolean deleteFiles )
        throws IOException
    {
        indexingContext.close( deleteFiles );
    }

    public void delete( final Collection<ArtifactInfo> artifacts )
        throws IOException
    {
        final List<ArtifactContext> delete = new ArrayList<>();
        for ( final ArtifactInfo artifact : artifacts )
        {
            LOGGER.debug( "Deleting artifact: {}; ctx id: {}; idx dir: {}",
                          new String[]{ artifact.toString(), indexingContext.getId(),
                              indexingContext.getIndexDirectory().toString() } );

            delete.add( new ArtifactContext( null, null, null, artifact, null ) );
        }

        getIndexer().deleteArtifactsFromIndex( delete, indexingContext );
    }

    public Set<ArtifactInfo> search( final String groupId, final String artifactId, final String version,
                                     final String packaging, final String classifier )
        throws IOException
    {
        final BooleanQuery query = new BooleanQuery();

        if ( groupId != null )
        {
            query.add( getIndexer().constructQuery( MAVEN.GROUP_ID, new SourcedSearchExpression( groupId ) ), MUST );
        }

        if ( artifactId != null )
        {
            query.add( getIndexer().constructQuery( MAVEN.ARTIFACT_ID, new SourcedSearchExpression( artifactId ) ),
                       MUST );
        }

        if ( version != null )
        {
            query.add( getIndexer().constructQuery( MAVEN.VERSION, new SourcedSearchExpression( version ) ), MUST );
        }

        if ( packaging != null )
        {
            query.add( getIndexer().constructQuery( MAVEN.PACKAGING, new SourcedSearchExpression( packaging ) ), MUST );
        }
        else
        {
            // Fallback to jar
            query.add( getIndexer().constructQuery( MAVEN.PACKAGING, new SourcedSearchExpression( "jar" ) ), MUST );
        }

        if ( classifier != null )
        {
            query.add( getIndexer().constructQuery( MAVEN.CLASSIFIER, new SourcedSearchExpression( classifier ) ),
                       MUST );
        }

        LOGGER.debug( "Executing search query: {}; ctx id: {}; idx dir: {}",
                      new String[]{ query.toString(), indexingContext.getId(),
                          indexingContext.getIndexDirectory().toString() } );

        final FlatSearchResponse response = getIndexer().searchFlat( new FlatSearchRequest( query, indexingContext ) );

        LOGGER.info( "Hit count: {}", response.getReturnedHitsCount() );

        final Set<ArtifactInfo> results = response.getResults();
        if ( LOGGER.isDebugEnabled() )
        {
            for ( final ArtifactInfo result : results )
            {
                LOGGER.debug( "Found artifact: {}", result.toString() );
            }
        }

        return results;
    }

    public Set<ArtifactInfo> search( final String queryText )
        throws ParseException, IOException
    {
        final Query query = new MultiFieldQueryParser( luceneFields, luceneAnalyzer ).parse( queryText );

        LOGGER.debug( "Executing search query: {}; ctx id: {}; idx dir: {}",
                      new String[]{ query.toString(), indexingContext.getId(),
                          indexingContext.getIndexDirectory().toString() } );

        final FlatSearchResponse response = getIndexer().searchFlat( new FlatSearchRequest( query, indexingContext ) );

        final Set<ArtifactInfo> results = response.getResults();
        if ( LOGGER.isDebugEnabled() )
        {
            LOGGER.debug( "Hit count: {}", response.getReturnedHitsCount() );

            for ( final ArtifactInfo result : results )
            {
                LOGGER.debug( "Found artifact: {}; uinfo: {}", result.toString(), result.getUinfo() );
            }
        }

        return results;
    }

    public Set<ArtifactInfo> searchBySHA1( final String checksum )
        throws IOException
    {
        final BooleanQuery query = new BooleanQuery();
        query.add( getIndexer().constructQuery( MAVEN.SHA1, new SourcedSearchExpression( checksum ) ), MUST );

        LOGGER.debug( "Executing search query: {}; ctx id: {}; idx dir: {}",
                      new String[]{ query.toString(), indexingContext.getId(),
                          indexingContext.getIndexDirectory().toString() } );

        final FlatSearchResponse response = getIndexer().searchFlat( new FlatSearchRequest( query, indexingContext ) );

        LOGGER.info( "Hit count: {}", response.getReturnedHitsCount() );

        final Set<ArtifactInfo> results = response.getResults();
        if ( LOGGER.isDebugEnabled() )
        {
            for ( final ArtifactInfo result : results )
            {
                LOGGER.debug( "Found artifact: {}", result.toString() );
            }
        }

        return results;
    }

    public int index( final File startingPath )
    {
        final ScanningResult scan = getScanner().scan(
            new ScanningRequest( indexingContext, new ReindexArtifactScanningListener(),
                                 startingPath == null ? "." : startingPath.getPath() ) );
        return scan.getTotalFiles();
    }

    public void addArtifactToIndex( final File artifactFile, final ArtifactInfo artifactInfo )
        throws IOException
    {
        getIndexer().addArtifactsToIndex( asList( new ArtifactContext( null, artifactFile, null, artifactInfo, null ) ),
                                          indexingContext );
    }

    public void addArtifactToIndex( String repository, File artifactFile, String groupId, String artifactId,
                                    String version, String extension, String classifier )
        throws IOException
    {
        ArtifactInfo artifactInfo = new ArtifactInfo( repository, groupId, artifactId, version, classifier, extension );
        if ( extension != null )
        {
            artifactInfo.setFieldValue( MAVEN.EXTENSION, extension );
        }

        LOGGER.debug( "Adding artifact: {}; repo: {}; type: {}",
                      new String[]{ artifactInfo.getUinfo(), repository, extension } );

        getIndexer().addArtifactsToIndex(
            asList( new ArtifactContext( null, artifactFile, null, artifactInfo, artifactInfo.calculateGav() ) ),
            indexingContext );
    }

    private class ReindexArtifactScanningListener
        implements ArtifactScanningListener
    {

        int totalFiles = 0;

        private IndexingContext context;

        @Override
        public void scanningStarted( final IndexingContext context )
        {
            this.context = context;
        }

        @Override
        public void scanningFinished( final IndexingContext context, final ScanningResult result )
        {
            result.setTotalFiles( totalFiles );
            LOGGER.debug( "Scanning finished; total files: {}; has exception: {}", result.getTotalFiles(),
                          result.hasExceptions() );
        }

        @Override
        public void artifactError( final ArtifactContext ac, final Exception ex )
        {
            LOGGER.error( "Artifact error!", ex );
        }

        @Override
        public void artifactDiscovered( final ArtifactContext ac )
        {
            try
            {
                LOGGER.debug( "Adding artifact gav: {}; ctx id: {}; idx dir: {}",
                              new String[]{ ac.getGav().toString(), context.getId(),
                                  context.getIndexDirectory().toString() } );

                getIndexer().addArtifactsToIndex( asList( ac ), context );
                totalFiles++;
            }
            catch ( IOException ex )
            {
                LOGGER.error( "Artifact index error", ex );
            }
        }
    }

    public Indexer getIndexer()
    {
        return indexer;
    }

    public void setIndexer( Indexer indexer )
    {
        this.indexer = indexer;
    }

    public Scanner getScanner()
    {
        return scanner;
    }

    public void setScanner( Scanner scanner )
    {
        this.scanner = scanner;
    }

    public List<IndexCreator> getIndexers()
    {
        return indexers;
    }

    public void setIndexers( List<IndexCreator> indexers )
    {
        this.indexers = indexers;
    }

    public IndexingContext getIndexingContext()
    {
        return indexingContext;
    }

    public void setIndexingContext( IndexingContext indexingContext )
    {
        this.indexingContext = indexingContext;
    }

    public String getRepositoryId()
    {
        return repositoryId;
    }

    public void setRepositoryId( String repositoryId )
    {
        this.repositoryId = repositoryId;
    }

    public File getRepositoryBasedir()
    {
        return repositoryBasedir;
    }

    public void setRepositoryBasedir( File repositoryBasedir )
    {
        this.repositoryBasedir = repositoryBasedir;
    }

    public File getIndexDir()
    {
        return indexDir;
    }

    public void setIndexDir( File indexDir )
    {
        this.indexDir = indexDir;
    }

}