org.alfresco.repo.search.impl.lucene
Class AbstractLuceneIndexerImpl

java.lang.Object
  extended by org.alfresco.repo.search.impl.lucene.AbstractLuceneBase
      extended by org.alfresco.repo.search.impl.lucene.AbstractLuceneIndexerImpl
All Implemented Interfaces:
Indexer
Direct Known Subclasses:
ADMLuceneIndexerImpl, AVMLuceneIndexerImpl

public abstract class AbstractLuceneIndexerImpl
extends AbstractLuceneBase
implements Indexer

Common support for indexing across implementations


Nested Class Summary
protected static class AbstractLuceneIndexerImpl.Action
          Enum for indexing actions against a node
protected static class AbstractLuceneIndexerImpl.Command
           
protected static class AbstractLuceneIndexerImpl.FTSStatus
           
protected static class AbstractLuceneIndexerImpl.IndexUpdateStatus
           
 
Field Summary
protected  java.util.List commandList
          List of pending indexing commands.
protected  java.util.Set containerDeletions
          A list of cascading container deletions we have made - at merge these deletions need to be made against the main index.
protected  java.util.Set deletions
          A list of all deletions we have made - at merge these deletions need to be made against the main index.
protected  long docs
           
protected  AbstractLuceneIndexerImpl.IndexUpdateStatus indexUpdateStatus
          Flag to indicte if we are doing an in transactional delta or a batch update to the index.
protected  long maxAtomicTransformationTime
          the maximum transformation time to allow atomically, defaulting to 20ms
static java.lang.String NOT_INDEXED_CONTENT_MISSING
          No content
static java.lang.String NOT_INDEXED_NO_TRANSFORMATION
          No transform available
static java.lang.String NOT_INDEXED_NO_TYPE_CONVERSION
          No type conversion
static java.lang.String NOT_INDEXED_TRANSFORMATION_FAILED
          Tranfrom failed
protected  TransactionService transactionService
           
 
Fields inherited from class org.alfresco.repo.search.impl.lucene.AbstractLuceneBase
deltaId, store
 
Constructor Summary
AbstractLuceneIndexerImpl()
           
 
Method Summary
protected  void checkAbleToDoWork(AbstractLuceneIndexerImpl.IndexUpdateStatus indexUpdateStatus)
          Utility method to check we are in the correct state to do work Also keeps track of the dirty flag.
 void commit()
          Commit this index
protected  void delete(java.lang.Object ref)
           
protected static java.util.Set deleteContainerAndBelow(java.lang.String nodeRef, org.apache.lucene.index.IndexReader reader, boolean delete, boolean cascade)
           
protected  boolean deleteLeafOnly(java.lang.String nodeRef, org.apache.lucene.index.IndexReader reader, boolean delete)
           
protected static java.util.Set deletePrimary(java.util.Collection nodeRefs, org.apache.lucene.index.IndexReader reader, boolean delete)
           
protected static java.util.Set deleteReference(java.util.Collection nodeRefs, org.apache.lucene.index.IndexReader reader, boolean delete)
           
protected abstract  void doCommit()
           
protected  java.lang.Object doInReadthroughTransaction(RetryingTransactionHelper.RetryingTransactionCallback callback)
           
protected abstract  void doPrepare()
           
protected abstract  void doRollBack()
           
protected abstract  void doSetRollbackOnly()
           
 java.util.Set getContainerDeletions()
          Get the container deletions
 java.util.Set getDeletions()
          Get the deletions
protected  void index(java.lang.Object ref)
           
 boolean isModified()
          Has this index been modified?
protected  boolean locateContainer(java.lang.String nodeRef, org.apache.lucene.index.IndexReader reader)
           
 int prepare()
          Prepare to commit At the moment this makes sure we have all the locks TODO: This is not doing proper serialisation against the index as would a data base transaction.
protected  void reindex(java.lang.Object ref, boolean cascadeReindexDirectories)
           
 void rollback()
          Roll back the index changes (this just means they are never added)
 void setMaxAtomicTransformationTime(long maxAtomicTransformationTime)
          Set the max time allowed to transform content atomically
 void setReadThrough(boolean isReadThrough)
          Activates 'read through' behaviour for this indexer.
 void setRollbackOnly()
          Mark this index for roll back only.
 void setTransactionService(TransactionService transactionService)
           
 
Methods inherited from class org.alfresco.repo.search.impl.lucene.AbstractLuceneBase
closeDeltaReader, closeDeltaWriter, deleteIndex, doReadOnly, getDeltaId, getDeltaReader, getDeltaWriter, getDictionaryService, getLuceneConfig, getReader, getSearcher, getSearcher, getStatus, initialise, saveDelta, setDictionaryService, setInfo, setLuceneConfig, setStatus
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface org.alfresco.repo.search.Indexer
createChildRelationship, createNode, deleteChildRelationship, deleteIndex, deleteNode, flushPending, updateChildRelationship, updateNode
 

Field Detail

docs

protected long docs

transactionService

protected TransactionService transactionService

NOT_INDEXED_NO_TRANSFORMATION

public static final java.lang.String NOT_INDEXED_NO_TRANSFORMATION
No transform available

See Also:
Constant Field Values

NOT_INDEXED_TRANSFORMATION_FAILED

public static final java.lang.String NOT_INDEXED_TRANSFORMATION_FAILED
Tranfrom failed

See Also:
Constant Field Values

NOT_INDEXED_CONTENT_MISSING

public static final java.lang.String NOT_INDEXED_CONTENT_MISSING
No content

See Also:
Constant Field Values

NOT_INDEXED_NO_TYPE_CONVERSION

public static final java.lang.String NOT_INDEXED_NO_TYPE_CONVERSION
No type conversion

See Also:
Constant Field Values

maxAtomicTransformationTime

protected long maxAtomicTransformationTime
the maximum transformation time to allow atomically, defaulting to 20ms


deletions

protected java.util.Set deletions
A list of all deletions we have made - at merge these deletions need to be made against the main index. TODO: Consider if this information needs to be persisted for recovery


containerDeletions

protected java.util.Set containerDeletions
A list of cascading container deletions we have made - at merge these deletions need to be made against the main index.


commandList

protected java.util.List commandList
List of pending indexing commands.


indexUpdateStatus

protected AbstractLuceneIndexerImpl.IndexUpdateStatus indexUpdateStatus
Flag to indicte if we are doing an in transactional delta or a batch update to the index. If true, we are just fixing up non atomically indexed things from one or more other updates.

Constructor Detail

AbstractLuceneIndexerImpl

public AbstractLuceneIndexerImpl()
Method Detail

setReadThrough

public void setReadThrough(boolean isReadThrough)
Description copied from interface: Indexer
Activates 'read through' behaviour for this indexer. Rather than accessing the database through the current (potentially old) transaction, it will use a discrete read only transaction for each node it indexes. This avoids 'stale' nodes building up in the caches during long reindex runs.

Specified by:
setReadThrough in interface Indexer

setTransactionService

public void setTransactionService(TransactionService transactionService)

deletePrimary

protected static java.util.Set deletePrimary(java.util.Collection nodeRefs,
                                             org.apache.lucene.index.IndexReader reader,
                                             boolean delete)
                                      throws LuceneIndexException
Throws:
LuceneIndexException

deleteReference

protected static java.util.Set deleteReference(java.util.Collection nodeRefs,
                                               org.apache.lucene.index.IndexReader reader,
                                               boolean delete)
                                        throws LuceneIndexException
Throws:
LuceneIndexException

deleteContainerAndBelow

protected static java.util.Set deleteContainerAndBelow(java.lang.String nodeRef,
                                                       org.apache.lucene.index.IndexReader reader,
                                                       boolean delete,
                                                       boolean cascade)
                                                throws LuceneIndexException
Throws:
LuceneIndexException

locateContainer

protected boolean locateContainer(java.lang.String nodeRef,
                                  org.apache.lucene.index.IndexReader reader)

deleteLeafOnly

protected boolean deleteLeafOnly(java.lang.String nodeRef,
                                 org.apache.lucene.index.IndexReader reader,
                                 boolean delete)
                          throws LuceneIndexException
Throws:
LuceneIndexException

setMaxAtomicTransformationTime

public void setMaxAtomicTransformationTime(long maxAtomicTransformationTime)
Set the max time allowed to transform content atomically

Parameters:
maxAtomicTransformationTime -

checkAbleToDoWork

protected void checkAbleToDoWork(AbstractLuceneIndexerImpl.IndexUpdateStatus indexUpdateStatus)
Utility method to check we are in the correct state to do work Also keeps track of the dirty flag.

Throws:
java.io.IOException

commit

public void commit()
            throws LuceneIndexException
Commit this index

Throws:
LuceneIndexException

prepare

public int prepare()
            throws LuceneIndexException
Prepare to commit At the moment this makes sure we have all the locks TODO: This is not doing proper serialisation against the index as would a data base transaction.

Returns:
the tx state
Throws:
LuceneIndexException

isModified

public boolean isModified()
Has this index been modified?

Returns:
true if modified

rollback

public void rollback()
              throws LuceneIndexException
Roll back the index changes (this just means they are never added)

Throws:
LuceneIndexException

setRollbackOnly

public void setRollbackOnly()
Mark this index for roll back only. This action can not be reversed. It will reject all other work and only allow roll back.


doPrepare

protected abstract void doPrepare()
                           throws java.io.IOException
Throws:
java.io.IOException

doCommit

protected abstract void doCommit()
                          throws java.io.IOException
Throws:
java.io.IOException

doRollBack

protected abstract void doRollBack()
                            throws java.io.IOException
Throws:
java.io.IOException

doSetRollbackOnly

protected abstract void doSetRollbackOnly()
                                   throws java.io.IOException
Throws:
java.io.IOException

doInReadthroughTransaction

protected java.lang.Object doInReadthroughTransaction(RetryingTransactionHelper.RetryingTransactionCallback callback)

index

protected void index(java.lang.Object ref)
              throws LuceneIndexException
Throws:
LuceneIndexException

reindex

protected void reindex(java.lang.Object ref,
                       boolean cascadeReindexDirectories)
                throws LuceneIndexException
Throws:
LuceneIndexException

delete

protected void delete(java.lang.Object ref)
               throws LuceneIndexException
Throws:
LuceneIndexException

getDeletions

public java.util.Set getDeletions()
Get the deletions

Returns:
- the ids to delete

getContainerDeletions

public java.util.Set getContainerDeletions()
Get the container deletions

Returns:
- the ids to delete


Copyright © 2005 - 2010 Alfresco Software, Inc. All Rights Reserved.