diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexConstants.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexConstants.java index 3ebcff7..c9889a3 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexConstants.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexConstants.java @@ -35,6 +35,8 @@ public interface IndexConstants { String REINDEX_ASYNC_PROPERTY_NAME = "reindex-async"; + String INDEXING_MODE_SYNC = "sync"; + String ASYNC_PROPERTY_NAME = "async"; String ASYNC_REINDEX_VALUE = "async-reindex"; diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdate.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdate.java index 4eabb5d..bdd1313 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdate.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdate.java @@ -209,7 +209,9 @@ public class IndexUpdate implements Editor { Editor editor = rootState.provider.getIndexEditor(type, definition, rootState.root, rootState.newCallback(indexPath, shouldReindex)); if (editor == null) { - missingProvider.onMissingIndex(type, definition, indexPath); + if (isReindexingModeMatching(rootState.async, definition)) { + missingProvider.onMissingIndex(type, definition, indexPath); + } } else if (shouldReindex) { if (definition.getBoolean(REINDEX_ASYNC_PROPERTY_NAME) && definition.getString(ASYNC_PROPERTY_NAME) == null) { @@ -235,13 +237,23 @@ public class IndexUpdate implements Editor { } } + private static boolean isReindexingModeMatching(String asyncRef, NodeBuilder definition) { + //It only gets invoked for case where index definition is included + //so just ensure that reindexing is not done for indexes which also + //support async when index update is sync + if (definition.hasProperty(ASYNC_PROPERTY_NAME) && asyncRef == null){ + return false; + } + return true; + } + static boolean isIncluded(String asyncRef, NodeBuilder definition) { if (definition.hasProperty(ASYNC_PROPERTY_NAME)) { PropertyState p = definition.getProperty(ASYNC_PROPERTY_NAME); List opt = newArrayList(p.getValue(Type.STRINGS)); if (asyncRef == null) { // sync index job, accept synonyms - return opt.contains("") || opt.contains("sync"); + return opt.contains("") || opt.contains(IndexConstants.INDEXING_MODE_SYNC); } else { return opt.contains(asyncRef); } diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateProvider.java index b03ee18..c0e19df 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateProvider.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateProvider.java @@ -27,6 +27,8 @@ import org.apache.jackrabbit.oak.spi.commit.VisibleEditor; import org.apache.jackrabbit.oak.spi.state.NodeBuilder; import org.apache.jackrabbit.oak.spi.state.NodeState; +import static com.google.common.base.Preconditions.checkNotNull; + public class IndexUpdateProvider implements EditorProvider { private static final IndexUpdateCallback NOOP_CALLBACK = @@ -53,10 +55,14 @@ public class IndexUpdateProvider implements EditorProvider { public IndexUpdateProvider( @Nonnull IndexEditorProvider provider, @CheckForNull String async, boolean failOnMissingIndexProvider) { + this(provider, async, createDefaultStrategy(failOnMissingIndexProvider)); + } + + public IndexUpdateProvider( + @Nonnull IndexEditorProvider provider, @CheckForNull String async, MissingIndexProviderStrategy missingStrategy) { this.provider = provider; this.async = async; - this.missingStrategy = new MissingIndexProviderStrategy(); - this.missingStrategy.setFailOnMissingIndexProvider(failOnMissingIndexProvider); + this.missingStrategy = checkNotNull(missingStrategy); } @Override @CheckForNull @@ -69,4 +75,10 @@ public class IndexUpdateProvider implements EditorProvider { return VisibleEditor.wrap(editor); } + private static MissingIndexProviderStrategy createDefaultStrategy(boolean failOnMissingIndexProvider) { + MissingIndexProviderStrategy missingStrategy = new MissingIndexProviderStrategy(); + missingStrategy.setFailOnMissingIndexProvider(failOnMissingIndexProvider); + return missingStrategy; + } + } diff --git oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateTest.java oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateTest.java index 1d73dec..d774761 100644 --- oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateTest.java +++ oak-core/src/test/java/org/apache/jackrabbit/oak/plugins/index/IndexUpdateTest.java @@ -37,6 +37,7 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; import javax.annotation.Nonnull; @@ -452,7 +453,7 @@ public class IndexUpdateTest { long t1 = getReindexCount(indexed); NodeBuilder b2 = indexed.builder(); - b2.child(INDEX_DEFINITIONS_NAME).child("rootIndex").setProperty(IndexConstants.REINDEX_PROPERTY_NAME, true); + b2.child(INDEX_DEFINITIONS_NAME).child("rootIndex").setProperty(REINDEX_PROPERTY_NAME, true); indexed = HOOK.processCommit(indexed, b2.getNodeState(), CommitInfo.EMPTY); long t2 = getReindexCount(indexed); @@ -601,4 +602,64 @@ public class IndexUpdateTest { assertTrue(IndexUpdate.isIncluded("async-other", base)); } + @Test + public void reindexAsyncMultiMode() throws Exception{ + NodeState before = builder.getNodeState(); + final String fooIndex = "fooIndex"; + NodeBuilder idx = createIndexDefinition(builder.child(INDEX_DEFINITIONS_NAME), + fooIndex, true, false, ImmutableSet.of("foo"), null); + idx.setProperty("async", asList("sync", "async"), Type.STRINGS); + + NodeState after = builder.getNodeState(); + + //Custom strategy to detect is missing is called for fooIndex + final AtomicBoolean missingInvoked = new AtomicBoolean(); + MissingIndexProviderStrategy missingStrategy = new MissingIndexProviderStrategy(){ + @Override + public void onMissingIndex(String type, NodeBuilder definition, String indexPath) throws CommitFailedException { + if (indexPath.endsWith(fooIndex)){ + missingInvoked.set(true); + } + super.onMissingIndex(type, definition, indexPath); + } + }; + + //Custom provider which gets invoked in both sync and async mode + //In sync mode for reindexing case it does not return an editor + IndexEditorProvider provider = new PropertyIndexEditorProvider(){ + @Override + public Editor getIndexEditor(@Nonnull String type, @Nonnull NodeBuilder definition, @Nonnull NodeState root, + @Nonnull IndexUpdateCallback callback) { + Editor editor = super.getIndexEditor(type, definition, root, callback); + IndexingContext context = ((ContextAwareCallback)callback).getIndexingContext(); + //Return null in case of reindexing done in sync mode + if (editor != null && !context.isAsync() && context.isReindexing()){ + return null; + } + return editor; + } + }; + + EditorHook asyncHook = new EditorHook(new IndexUpdateProvider(provider, "async", missingStrategy)); + EditorHook syncHook = new EditorHook(new IndexUpdateProvider(provider, null, missingStrategy)); + + NodeState indexed = asyncHook.processCommit(before, after, CommitInfo.EMPTY); + + builder = indexed.builder(); + builder.child("oak:index").child(fooIndex).setProperty(REINDEX_PROPERTY_NAME, true); + + before = indexed; + after = builder.getNodeState(); + + //For async case things should be fine + indexed = asyncHook.processCommit(before, after, CommitInfo.EMPTY); + assertFalse(missingInvoked.get()); + //Reindex flag should get reset + assertFalse(indexed.getChildNode("oak:index").getChildNode(fooIndex).getBoolean(REINDEX_PROPERTY_NAME)); + + indexed = syncHook.processCommit(before, after, CommitInfo.EMPTY); + assertFalse("MissingIndexProvider strategy should not have been invoked for sync mode", missingInvoked.get()); + //Reindex flag should not get reset + assertTrue(indexed.getChildNode("oak:index").getChildNode(fooIndex).getBoolean(REINDEX_PROPERTY_NAME)); + } }