package org.apache.maven.index.context;
/*
* 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 java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.IndexInput;
import org.apache.lucene.store.IndexOutput;
import org.apache.maven.index.ArtifactInfo;
import org.codehaus.plexus.util.FileUtils;
public class IndexUtils
{
public static final String TIMESTAMP_FILE = "timestamp";
private static final int BUFFER_SIZE = 16384;
// Directory
public static void copyDirectory( Directory source, Directory target )
throws IOException
{
// perform plain copy (but semantic changes between Lucene 2.4 and 2.9 exists, so timestamp file will be not
// copied in 2.9)
Directory.copy( source, target, false );
copyFile( source, target, IndexingContext.INDEX_UPDATER_PROPERTIES_FILE );
copyFile( source, target, IndexingContext.INDEX_PACKER_PROPERTIES_FILE );
Date ts = getTimestamp( source );
updateTimestamp( target, ts );
}
public static boolean copyFile( Directory source, Directory target, String name )
throws IOException
{
return copyFile( source, target, name, name );
}
public static boolean copyFile( Directory source, Directory target, String srcName, String targetName )
throws IOException
{
if ( !source.fileExists( srcName ) )
{
return false;
}
byte[] buf = new byte[BUFFER_SIZE];
IndexInput is = null;
IndexOutput os = null;
try
{
is = source.openInput( srcName );
os = target.createOutput( targetName );
// and copy to dest directory
long len = is.length();
long readCount = 0;
while ( readCount < len )
{
int toRead = readCount + BUFFER_SIZE > len ? (int) ( len - readCount ) : BUFFER_SIZE;
is.readBytes( buf, 0, toRead );
os.writeBytes( buf, toRead );
readCount += toRead;
}
return true;
}
finally
{
close( os );
close( is );
}
}
// timestamp
public static ArtifactInfo constructArtifactInfo( Document doc, IndexingContext context )
{
// if no UINFO can't create, must be a different type of record
if ( doc.get( ArtifactInfo.UINFO ) == null )
{
return null;
}
boolean res = false;
ArtifactInfo artifactInfo = new ArtifactInfo();
for ( IndexCreator ic : context.getIndexCreators() )
{
res |= ic.updateArtifactInfo( doc, artifactInfo );
}
return res ? artifactInfo : null;
}
public static Document updateDocument( Document doc, IndexingContext context )
{
return updateDocument( doc, context, true );
}
public static Document updateDocument( Document doc, IndexingContext context, boolean updateLastModified )
{
ArtifactInfo ai = constructArtifactInfo( doc, context );
if ( ai == null )
{
return doc;
}
Document document = new Document();
// unique key
document.add( new Field( ArtifactInfo.UINFO, ai.getUinfo(), Field.Store.YES, Field.Index.NOT_ANALYZED ) );
if ( updateLastModified || doc.getField( ArtifactInfo.LAST_MODIFIED ) == null )
{
document.add( new Field( ArtifactInfo.LAST_MODIFIED, //
Long.toString( System.currentTimeMillis() ), Field.Store.YES, Field.Index.NO ) );
}
else
{
document.add( doc.getField( ArtifactInfo.LAST_MODIFIED ) );
}
for ( IndexCreator ic : context.getIndexCreators() )
{
ic.updateDocument( ai, document );
}
return document;
}
public static void deleteTimestamp( Directory directory )
throws IOException
{
if ( directory.fileExists( TIMESTAMP_FILE ) )
{
directory.deleteFile( TIMESTAMP_FILE );
}
}
public static void updateTimestamp( Directory directory, Date timestamp )
throws IOException
{
synchronized ( directory )
{
Date currentTimestamp = getTimestamp( directory );
if ( timestamp != null && ( currentTimestamp == null || !currentTimestamp.equals( timestamp ) ) )
{
deleteTimestamp( directory );
IndexOutput io = directory.createOutput( TIMESTAMP_FILE );
try
{
io.writeLong( timestamp.getTime() );
io.flush();
}
finally
{
close( io );
}
}
}
}
public static Date getTimestamp( Directory directory )
{
synchronized ( directory )
{
Date result = null;
try
{
if ( directory.fileExists( TIMESTAMP_FILE ) )
{
IndexInput ii = null;
try
{
ii = directory.openInput( TIMESTAMP_FILE );
result = new Date( ii.readLong() );
}
finally
{
close( ii );
}
}
}
catch ( IOException ex )
{
}
return result;
}
}
// close helpers
public static void close( OutputStream os )
{
if ( os != null )
{
try
{
os.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( InputStream is )
{
if ( is != null )
{
try
{
is.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( IndexOutput io )
{
if ( io != null )
{
try
{
io.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( IndexInput in )
{
if ( in != null )
{
try
{
in.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( IndexReader r )
{
if ( r != null )
{
try
{
r.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( IndexWriter w )
{
if ( w != null )
{
try
{
w.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void close( Directory d )
{
if ( d != null )
{
try
{
d.close();
}
catch ( IOException e )
{
// ignore
}
}
}
public static void delete( File indexDir )
{
try
{
FileUtils.deleteDirectory( indexDir );
}
catch ( IOException ex )
{
// ignore
}
}
}