You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by kl...@apache.org on 2017/02/22 21:38:20 UTC
[1/5] geode git commit: GEODE-2522: Flattened heirarchy of Lucene
DUnit tests
Repository: geode
Updated Branches:
refs/heads/feature/GEODE-2460 8065b6729 -> 1a57f636f
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
new file mode 100644
index 0000000..bf12e79
--- /dev/null
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceDUnitTest.java
@@ -0,0 +1,200 @@
+/*
+ * 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.
+ */
+
+package org.apache.geode.cache.lucene;
+
+import static org.apache.geode.cache.lucene.test.IndexRepositorySpy.doOnce;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.any;
+
+import java.util.stream.IntStream;
+
+import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.InitialImageOperation;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
+import org.apache.geode.test.dunit.Host;
+import org.apache.geode.test.junit.categories.DistributedTest;
+import org.junit.After;
+import org.junit.Test;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.control.RebalanceOperation;
+import org.apache.geode.cache.control.RebalanceResults;
+import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
+import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
+import org.apache.geode.cache.partition.PartitionRegionHelper;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
+import org.apache.geode.test.dunit.VM;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+
+/**
+ * This test class adds more basic tests of lucene functionality for partitioned regions. These
+ * tests should work across all types of PRs and topologies.
+ *
+ */
+@Category(DistributedTest.class)
+@RunWith(JUnitParamsRunner.class)
+public class RebalanceDUnitTest extends LuceneQueriesAccessorBase {
+
+ protected static int NUM_BUCKETS = 10;
+
+
+ @After
+ public void cleanupRebalanceCallback() {
+ removeCallback(dataStore1);
+ removeCallback(dataStore2);
+ }
+
+ protected Object[] getListOfClientServerTypes() {
+ return new Object[] {
+ new RegionTestableType[] {RegionTestableType.PARTITION_PROXY, RegionTestableType.PARTITION},
+ new RegionTestableType[] {RegionTestableType.PARTITION_PROXY_WITH_OVERFLOW,
+ RegionTestableType.PARTITION_OVERFLOW_TO_DISK}};
+ }
+
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenRebalanceHappensOnIndexUpdate(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ addCallbackToTriggerRebalance(dataStore1);
+
+ putEntriesAndValidateQueryResults(clientType, regionType);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenMoveBucketHappensOnIndexUpdate(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ addCallbackToMoveBucket(dataStore1, member2);
+
+ putEntriesAndValidateQueryResults(clientType, regionType);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenMoveBucketHappensOnQuery(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ addCallbackToMovePrimaryOnQuery(dataStore1, member2);
+
+ putEntriesAndValidateQueryResults(clientType, regionType);
+ }
+
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenBucketIsMovedAndMovedBackOnIndexUpdate(
+ RegionTestableType clientType, RegionTestableType regionType) throws InterruptedException {
+ final DistributedMember member1 =
+ dataStore1.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ addCallbackToMoveBucket(dataStore1, member2);
+ addCallbackToMoveBucket(dataStore2, member1);
+
+ putEntriesAndValidateQueryResults(clientType, regionType);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenRebalanceHappensAfterUpdates(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+
+ putEntryInEachBucket();
+
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+
+ rebalanceRegion(dataStore2);
+
+ executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenRebalanceHappensWhileSenderIsPaused(
+ RegionTestableType clientType, RegionTestableType regionType) throws InterruptedException {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+
+ putEntryInEachBucket();
+
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ rebalanceRegion(dataStore2);
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+
+ executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
+ }
+
+ protected void putEntriesAndValidateQueryResults(RegionTestableType clientType,
+ RegionTestableType regionType) {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+
+ putEntryInEachBucket();
+
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+
+ // dataStore3.invoke(() -> initDataStore(createIndex, regionType));
+ executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
+ }
+
+ // Duplicated for now, try to abstract this out...
+ protected void putEntryInEachBucket() {
+ accessor.invoke(() -> {
+ final Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
+ IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
+ });
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
new file mode 100644
index 0000000..071bd7c
--- /dev/null
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/RebalanceWithRedundancyDUnitTest.java
@@ -0,0 +1,181 @@
+/*
+ * 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.
+ */
+package org.apache.geode.cache.lucene;
+
+import static org.apache.geode.cache.lucene.test.IndexRepositorySpy.*;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
+import static org.junit.Assert.*;
+
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.CacheClosedException;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.lucene.test.IndexRegionSpy;
+import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
+import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.InitialImageOperation;
+import org.apache.geode.internal.cache.InitialImageOperation.GIITestHook;
+import org.apache.geode.internal.cache.InitialImageOperation.GIITestHookType;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
+import org.apache.geode.test.dunit.VM;
+import org.apache.geode.test.junit.categories.DistributedTest;
+
+import org.awaitility.Awaitility;
+
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+
+@Category(DistributedTest.class)
+@RunWith(JUnitParamsRunner.class)
+public class RebalanceWithRedundancyDUnitTest extends LuceneQueriesAccessorBase {
+
+ @Override
+ protected Object[] getListOfClientServerTypes() {
+ return new Object[] {new RegionTestableType[] {RegionTestableType.PARTITION_PROXY_REDUNDANT,
+ RegionTestableType.PARTITION_REDUNDANT}};
+ }
+
+ protected void putEntryInEachBucket() {
+ accessor.invoke(() -> {
+ final Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
+ IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
+ });
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenMovePrimaryHappensOnIndexUpdate(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ addCallbackToMovePrimary(dataStore1, member2);
+
+ putEntriesAndValidateResultsWithRedundancy(clientType, regionType);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenCloseCacheHappensOnIndexUpdate(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ dataStore1.invoke(() -> {
+ IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
+
+ spy.beforeWriteIndexRepository(doAfterN(key -> getCache().close(), 2));
+ });
+
+ final String expectedExceptions = CacheClosedException.class.getName();
+ dataStore1.invoke(addExceptionTag1(expectedExceptions));
+
+ putEntriesAndValidateResultsWithRedundancy(clientType, regionType);
+
+ // Wait until the cache is closed in datastore1
+ dataStore1.invoke(
+ () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenCloseCacheHappensOnPartialIndexWrite(
+ RegionTestableType clientType, RegionTestableType regionType) throws InterruptedException {
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ dataStore1.invoke(() -> {
+ IndexRegionSpy.beforeWrite(getCache(), doAfterN(key -> getCache().close(), 100));
+ });
+
+ putEntriesAndValidateResultsWithRedundancy(clientType, regionType);
+
+ // Wait until the cache is closed in datastore1
+ dataStore1.invoke(
+ () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsWhenIndexUpdateHappensIntheMiddleofGII(
+ RegionTestableType clientType, RegionTestableType regionType) throws InterruptedException {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+ putEntryInEachBucket();
+
+ dataStore2.invoke(() -> {
+ InitialImageOperation.setGIITestHook(
+ new GIITestHook(GIITestHookType.AfterSentRequestImage, "Do puts during request") {
+ @Override
+ public void reset() {
+
+ }
+
+ @Override
+ public String getRegionName() {
+ return "_B__index#__region.files_0";
+ }
+
+ @Override
+ public void run() {
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ waitForFlushBeforeExecuteTextSearch(dataStore1, 30000);
+ }
+ });
+ });
+
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 30000));
+ executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
+ }
+
+ private void putEntriesAndValidateResultsWithRedundancy(RegionTestableType clientType,
+ RegionTestableType regionType) {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+ dataStore2.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+ accessor.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+
+ putEntryInEachBucket();
+
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ accessor.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore2, 60000));
+
+ executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/test/LuceneTestUtilities.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/test/LuceneTestUtilities.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/test/LuceneTestUtilities.java
index 5a6f774..329dee9 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/test/LuceneTestUtilities.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/test/LuceneTestUtilities.java
@@ -83,7 +83,7 @@ public class LuceneTestUtilities {
public static String Quarter3 = "Q3";
public static String Quarter4 = "Q4";
- public static void initDataStoreForFixedPR(final Cache cache) throws Exception {
+ public static Region initDataStoreForFixedPR(final Cache cache) throws Exception {
List<FixedPartitionAttributes> fpaList = new ArrayList<FixedPartitionAttributes>();
int vmNum = VM.getCurrentVMNum();
if (vmNum % 2 == 0) {
@@ -102,10 +102,10 @@ public class LuceneTestUtilities {
fpaList.add(fpa2);
}
- createFixedPartitionedRegion(cache, REGION_NAME, fpaList, 40);
+ return createFixedPartitionedRegion(cache, REGION_NAME, fpaList, 40);
}
- public static void createFixedPartitionedRegion(final Cache cache, String regionName,
+ public static Region createFixedPartitionedRegion(final Cache cache, String regionName,
List<FixedPartitionAttributes> fpaList, int localMaxMemory) {
List<String> allPartitions = new ArrayList();
if (fpaList != null) {
@@ -132,6 +132,7 @@ public class LuceneTestUtilities {
fact.setPartitionAttributes(pfact.create());
Region r = cache.createRegionFactory(fact.create()).create(regionName);
assertNotNull(r);
+ return r;
}
static class MyFixedPartitionResolver implements FixedPartitionResolver {
[5/5] geode git commit: update dependency version
Posted by kl...@apache.org.
update dependency version
Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/1a57f636
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/1a57f636
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/1a57f636
Branch: refs/heads/feature/GEODE-2460
Commit: 1a57f636ffeadb83f421bd249ceba91cf753f3e2
Parents: 76fa7cc
Author: Kirk Lund <kl...@apache.org>
Authored: Wed Feb 22 13:33:23 2017 -0800
Committer: Kirk Lund <kl...@apache.org>
Committed: Wed Feb 22 13:37:17 2017 -0800
----------------------------------------------------------------------
geode-assembly/src/main/dist/NOTICE | 4 ++--
geode-pulse/src/main/webapp/META-INF/NOTICE | 4 ++--
geode-web-api/src/main/webapp/META-INF/NOTICE | 4 ++--
geode-web/src/main/webapp/META-INF/NOTICE | 4 ++--
gradle/dependency-versions.properties | 24 +++++++++++-----------
5 files changed, 20 insertions(+), 20 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/geode/blob/1a57f636/geode-assembly/src/main/dist/NOTICE
----------------------------------------------------------------------
diff --git a/geode-assembly/src/main/dist/NOTICE b/geode-assembly/src/main/dist/NOTICE
index 3ce86ba..097bd7f 100644
--- a/geode-assembly/src/main/dist/NOTICE
+++ b/geode-assembly/src/main/dist/NOTICE
@@ -121,8 +121,8 @@ Apache Lucene
Servlet-api.jar and javax.servlet-*.jar are under the CDDL license, the original
source code for this can be found at http://www.eclipse.org/jetty/downloads.php
-Spring Framework 4.3.2.RELEASE
-Copyright (c) 2002-2015 Pivotal, Inc.
+Spring Framework 4.3.6.RELEASE
+Copyright (c) 2002-2017 Pivotal, Inc.
This product is licensed to you under the Apache License, Version 2.0
(the "License"). You may not use this product except in compliance with
http://git-wip-us.apache.org/repos/asf/geode/blob/1a57f636/geode-pulse/src/main/webapp/META-INF/NOTICE
----------------------------------------------------------------------
diff --git a/geode-pulse/src/main/webapp/META-INF/NOTICE b/geode-pulse/src/main/webapp/META-INF/NOTICE
index 95c619c..dbbba76 100644
--- a/geode-pulse/src/main/webapp/META-INF/NOTICE
+++ b/geode-pulse/src/main/webapp/META-INF/NOTICE
@@ -45,8 +45,8 @@ Jackson Core 2.8.0
in some artifacts (usually source distributions); but is always available
from the source code management (SCM) system project uses.
-Spring Framework 4.3.2.RELEASE
-Copyright (c) 2002-2015 Pivotal, Inc.
+Spring Framework 4.3.6.RELEASE
+Copyright (c) 2002-2017 Pivotal, Inc.
This product is licensed to you under the Apache License, Version 2.0
(the "License"). You may not use this product except in compliance with
http://git-wip-us.apache.org/repos/asf/geode/blob/1a57f636/geode-web-api/src/main/webapp/META-INF/NOTICE
----------------------------------------------------------------------
diff --git a/geode-web-api/src/main/webapp/META-INF/NOTICE b/geode-web-api/src/main/webapp/META-INF/NOTICE
index 004cd5f..67ccc2c 100644
--- a/geode-web-api/src/main/webapp/META-INF/NOTICE
+++ b/geode-web-api/src/main/webapp/META-INF/NOTICE
@@ -51,8 +51,8 @@ Jackson Core 2.8.2
in some artifacts (usually source distributions); but is always available
from the source code management (SCM) system project uses.
-Spring Framework 4.3.2.RELEASE
-Copyright (c) 2002-2015 Pivotal, Inc.
+Spring Framework 4.3.6.RELEASE
+Copyright (c) 2002-2017 Pivotal, Inc.
This product is licensed to you under the Apache License, Version 2.0
(the "License"). You may not use this product except in compliance with
http://git-wip-us.apache.org/repos/asf/geode/blob/1a57f636/geode-web/src/main/webapp/META-INF/NOTICE
----------------------------------------------------------------------
diff --git a/geode-web/src/main/webapp/META-INF/NOTICE b/geode-web/src/main/webapp/META-INF/NOTICE
index a8caa6b..2591148 100644
--- a/geode-web/src/main/webapp/META-INF/NOTICE
+++ b/geode-web/src/main/webapp/META-INF/NOTICE
@@ -22,8 +22,8 @@ project (http://mx4j.sourceforge.net).
This project includes software licensed under the JSON license.
-Spring Framework 4.3.2.RELEASE
-Copyright (c) 2002-2015 Pivotal, Inc.
+Spring Framework 4.3.6.RELEASE
+Copyright (c) 2002-2017 Pivotal, Inc.
This product is licensed to you under the Apache License, Version 2.0
(the "License"). You may not use this product except in compliance with
http://git-wip-us.apache.org/repos/asf/geode/blob/1a57f636/gradle/dependency-versions.properties
----------------------------------------------------------------------
diff --git a/gradle/dependency-versions.properties b/gradle/dependency-versions.properties
index 12a76b4..2a3169d 100644
--- a/gradle/dependency-versions.properties
+++ b/gradle/dependency-versions.properties
@@ -17,7 +17,7 @@
activation.version = 1.1.1
annotations.version = 3.0.0
antlr.version = 2.7.7
-asm.version = 5.1
+asm.version = 5.2
assertj-core.version = 3.6.2
awaitility.version = 2.0.0
bcel.version = 6.0
@@ -38,7 +38,7 @@ commons-digester.version=2.1
commons-exec.version=1.3
derby.version = 10.13.1.1
dom4j.version = 1.6.1
-fastutil.version = 7.0.13
+fastutil.version = 7.1.0
google-gson.version=2.8.0
guava.version = 21.0
hadoop.version = 2.4.1
@@ -46,7 +46,7 @@ hamcrest-all.version = 1.3
hbase.version = 0.94.27
hibernate.version = 3.5.5-Final
hibernate-commons-annotations.version = 3.2.0.Final
-httpclient.version = 4.5.2
+httpclient.version = 4.5.3
httpcore.version = 4.4.6
httpunit.version = 1.7.2
hsqldb.version = 2.3.4
@@ -84,8 +84,8 @@ multithreadedtc.version = 1.01
mx4j.version = 3.0.1
mx4j-remote.version = 3.0.1
mx4j-tools.version = 3.0.1
-netty-all.version = 4.1.7.Final
-open-json.version = 1.7
+netty-all.version = 4.1.8.Final
+open-json.version = 1.8
paranamer.version = 2.3
phantomjsdriver.version=1.3.0
powermock.version = 1.6.6
@@ -93,17 +93,17 @@ quartz.version = 2.2.1
scala.version = 2.10.0
selenium.version=3.0.1
shiro.version=1.3.2
-slf4j-api.version = 1.7.22
+slf4j-api.version = 1.7.23
snappy-java.version=0.4
-spring-hateoas.version = 0.21.0.RELEASE
+spring-hateoas.version = 0.23.0.RELEASE
spring-shell.version = 1.2.0.RELEASE
-spring-ldap-core.version = 2.1.0.RELEASE
-spring-security.version = 4.1.3.RELEASE
-spring-tx.version = 4.3.2.RELEASE
-springframework.version = 4.3.2.RELEASE
+spring-ldap-core.version = 2.3.1.RELEASE
+spring-security.version = 4.2.1.RELEASE
+spring-tx.version = 4.3.6.RELEASE
+springframework.version = 4.3.6.RELEASE
stephenc-findbugs.version = 1.3.9-1
spymemcached.version = 2.12.2
-springfox.version=2.6.0
+springfox.version=2.6.1
system-rules.version = 1.16.1
tempus-fugit.version = 1.1
tomcat6.version = 6.0.37
[4/5] geode git commit: GEODE-2514: add new tests for statistics
archive rolling and removal
Posted by kl...@apache.org.
GEODE-2514: add new tests for statistics archive rolling and removal
* add MainWithChildrenRollingFileHandlerIntegrationTest
* add StatArchiveHandlerIntegrationTest
* expand DiskSpaceLimitIntegrationTest
Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/76fa7cc7
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/76fa7cc7
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/76fa7cc7
Branch: refs/heads/feature/GEODE-2460
Commit: 76fa7cc7300359afa83c5df30d3af4043b82da27
Parents: a63b830
Author: Kirk Lund <kl...@apache.org>
Authored: Tue Feb 21 13:09:24 2017 -0800
Committer: Kirk Lund <kl...@apache.org>
Committed: Wed Feb 22 12:47:10 2017 -0800
----------------------------------------------------------------------
.../io/MainWithChildrenRollingFileHandler.java | 6 +-
.../internal/statistics/StatArchiveHandler.java | 6 +-
...ildrenRollingFileHandlerIntegrationTest.java | 96 ++++++++
.../DiskSpaceLimitIntegrationTest.java | 245 ++++++++++++++++++-
.../StatArchiveHandlerIntegrationTest.java | 243 ++++++++++++++++++
5 files changed, 582 insertions(+), 14 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/geode/blob/76fa7cc7/geode-core/src/main/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandler.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandler.java b/geode-core/src/main/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandler.java
index 20d1c4f..11d10af 100644
--- a/geode-core/src/main/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandler.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandler.java
@@ -206,7 +206,11 @@ public class MainWithChildrenRollingFileHandler implements RollingFileHandler {
return tmp;
}
- private Pattern getFilePattern(String name) {
+ Pattern getFilePattern(String name) {
+ if (name == null || "".equals(name.trim())) {
+ throw new IllegalArgumentException("Name must not be empty");
+ }
+
int extIdx = name.lastIndexOf('.');
String ext = "";
if (extIdx != -1) {
http://git-wip-us.apache.org/repos/asf/geode/blob/76fa7cc7/geode-core/src/main/java/org/apache/geode/internal/statistics/StatArchiveHandler.java
----------------------------------------------------------------------
diff --git a/geode-core/src/main/java/org/apache/geode/internal/statistics/StatArchiveHandler.java b/geode-core/src/main/java/org/apache/geode/internal/statistics/StatArchiveHandler.java
index 3eb9730..03b0f89 100755
--- a/geode-core/src/main/java/org/apache/geode/internal/statistics/StatArchiveHandler.java
+++ b/geode-core/src/main/java/org/apache/geode/internal/statistics/StatArchiveHandler.java
@@ -446,7 +446,7 @@ public class StatArchiveHandler implements SampleHandler {
* @return the modified archive file name to use; it is modified by applying mainArchiveId and
* archiveId to the name for supporting file rolling
*/
- private File getRollingArchiveName(File archive, boolean archiveClosed) {
+ File getRollingArchiveName(File archive, boolean archiveClosed) {
if (mainArchiveId != -1) {
// leave mainArchiveId as is. Bump archiveId.
} else {
@@ -538,7 +538,7 @@ public class StatArchiveHandler implements SampleHandler {
return result;
}
- private void initMainArchiveId(File archive) {
+ void initMainArchiveId(File archive) {
if (mainArchiveId != -1) {
// already initialized
return;
@@ -598,7 +598,7 @@ public class StatArchiveHandler implements SampleHandler {
* @return the modified archive file name to use; it is modified by applying the next main id if
* any files in the dir already have a main id in the file name
*/
- private File getRenameArchiveName(File archive) {
+ File getRenameArchiveName(File archive) {
File dir = archive.getAbsoluteFile().getParentFile();
int previousMainId = this.rollingFileHandler.calcNextMainId(dir, false);
if (previousMainId == 0) {
http://git-wip-us.apache.org/repos/asf/geode/blob/76fa7cc7/geode-core/src/test/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandlerIntegrationTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandlerIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandlerIntegrationTest.java
new file mode 100644
index 0000000..5ea77c4
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/internal/io/MainWithChildrenRollingFileHandlerIntegrationTest.java
@@ -0,0 +1,96 @@
+/*
+ * 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.
+ */
+package org.apache.geode.internal.io;
+
+import static org.assertj.core.api.Assertions.*;
+
+import java.util.regex.Pattern;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.TestName;
+
+import org.apache.geode.test.junit.categories.IntegrationTest;
+
+@Category(IntegrationTest.class)
+public class MainWithChildrenRollingFileHandlerIntegrationTest {
+
+ private String name;
+ private MainWithChildrenRollingFileHandler handler;
+
+ @Rule
+ public TestName testName = new TestName();
+
+ @Before
+ public void before() throws Exception {
+ this.name = this.testName.getMethodName();
+ this.handler = new MainWithChildrenRollingFileHandler();
+ }
+
+ @Test
+ public void getFilePattern_matchesFilesWithBothIds() throws Exception {
+ Pattern pattern = this.handler.getFilePattern(this.name);
+
+ assertThat(pattern).isNotNull();
+ assertThat(pattern.matcher(this.name).matches()).isFalse();
+ assertThat(pattern.matcher(this.name + "-01-01").matches()).isTrue();
+ assertThat(pattern.matcher(this.name + "-01-02").matches()).isTrue();
+ assertThat(pattern.matcher(this.name + "-02-01").matches()).isTrue();
+ assertThat(pattern.matcher(this.name + "-01").matches()).isFalse();
+ assertThat(pattern.matcher(this.name + "0101").matches()).isFalse();
+ assertThat(pattern.matcher(this.name + "--").matches()).isFalse();
+
+ // TODO: revisit these to determine if behavior should change
+ assertThat(pattern.matcher(this.name + "-01-01-01").matches()).isFalse();
+ assertThat(pattern.matcher(this.name + ".01-01-01").matches()).isFalse();
+ }
+
+ @Test
+ public void getFilePattern_withNumbers_matchesFiles() throws Exception {
+ this.name = "a1s2d3f4_cache1_statistics";
+ Pattern pattern = this.handler.getFilePattern(this.name);
+
+ assertThat(pattern).isNotNull();
+ assertThat(pattern.matcher(this.name + "-01-41").matches()).isTrue();
+ }
+
+ @Test
+ public void getFilePattern_withHyphens_matchesFiles() throws Exception {
+ this.name = "a1s2d3f4_cache1-statistics";
+ Pattern pattern = this.handler.getFilePattern(this.name);
+
+ assertThat(pattern).isNotNull();
+ assertThat(pattern.matcher(this.name + "-01-41").matches()).isTrue();
+ }
+
+ @Test
+ public void getFilePattern_empty_throwsIllegalArgumentException() throws Exception {
+ this.name = "";
+
+ assertThatThrownBy(() -> this.handler.getFilePattern(this.name))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test
+ public void getFilePattern_null_throwsIllegalArgumentException() throws Exception {
+ this.name = null;
+
+ assertThatThrownBy(() -> this.handler.getFilePattern(this.name))
+ .isInstanceOf(IllegalArgumentException.class);
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/76fa7cc7/geode-core/src/test/java/org/apache/geode/internal/statistics/DiskSpaceLimitIntegrationTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/internal/statistics/DiskSpaceLimitIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/internal/statistics/DiskSpaceLimitIntegrationTest.java
index 1702d9a..5d94fa0 100644
--- a/geode-core/src/test/java/org/apache/geode/internal/statistics/DiskSpaceLimitIntegrationTest.java
+++ b/geode-core/src/test/java/org/apache/geode/internal/statistics/DiskSpaceLimitIntegrationTest.java
@@ -14,8 +14,10 @@
*/
package org.apache.geode.internal.statistics;
+import static java.lang.String.valueOf;
import static java.util.concurrent.TimeUnit.MINUTES;
-import static org.apache.commons.io.FileUtils.moveFileToDirectory;
+import static org.apache.commons.io.FileUtils.*;
+import static org.apache.commons.lang.StringUtils.leftPad;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -37,9 +39,14 @@ import org.junit.rules.TestName;
import java.io.File;
import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
import java.util.concurrent.TimeoutException;
@Category(IntegrationTest.class)
+@SuppressWarnings("unused")
public class DiskSpaceLimitIntegrationTest {
private static final long FILE_SIZE_LIMIT = 256;
@@ -48,6 +55,8 @@ public class DiskSpaceLimitIntegrationTest {
private File dir;
private File dirOfDeletedFiles;
+ private String name;
+
private String archiveFileName;
private LocalStatisticsFactory factory;
@@ -55,9 +64,14 @@ public class DiskSpaceLimitIntegrationTest {
private StatisticsType statisticsType;
private Statistics statistics;
+ private RollingFileHandler testRollingFileHandler;
+ private MainWithChildrenRollingFileHandler mainWithChildrenRollingFileHandler;
+
private SampleCollector sampleCollector;
private StatArchiveHandlerConfig config;
+ private long initTimeStamp;
+
private NanoTimer timer = new NanoTimer();
private long nanosTimeStamp;
@@ -69,10 +83,10 @@ public class DiskSpaceLimitIntegrationTest {
@Before
public void setUp() throws Exception {
this.dir = this.temporaryFolder.getRoot();
- this.dirOfDeletedFiles = this.temporaryFolder.newFolder("deleted");
- this.archiveFileName =
- new File(this.dir, this.testName.getMethodName() + ".gfs").getAbsolutePath();
+ this.name = this.testName.getMethodName();
+
+ this.archiveFileName = new File(this.dir, this.name + ".gfs").getAbsolutePath();
this.factory = new LocalStatisticsFactory(null);
this.statisticDescriptors = new StatisticDescriptor[] {
@@ -93,11 +107,12 @@ public class DiskSpaceLimitIntegrationTest {
.thenReturn(this.temporaryFolder.getRoot().getAbsolutePath());
when(this.config.getProductDescription()).thenReturn(this.testName.getMethodName());
- RollingFileHandler rollingFileHandler = new TestableRollingFileHandler();
+ this.testRollingFileHandler = new TestableRollingFileHandler();
+ this.mainWithChildrenRollingFileHandler = new MainWithChildrenRollingFileHandler();
this.sampleCollector = new SampleCollector(sampler);
- this.sampleCollector.initialize(this.config, NanoTimer.getTime(), rollingFileHandler);
+ this.initTimeStamp = NanoTimer.getTime();
this.timer.reset();
this.nanosTimeStamp = this.timer.getLastResetTime() - getNanoRate();
}
@@ -109,6 +124,9 @@ public class DiskSpaceLimitIntegrationTest {
@Test
public void zeroKeepsAllFiles() throws Exception {
+ this.dirOfDeletedFiles = this.temporaryFolder.newFolder("deleted");
+ this.sampleCollector.initialize(this.config, this.initTimeStamp, this.testRollingFileHandler);
+
when(this.config.getArchiveDiskSpaceLimit()).thenReturn(0L);
sampleUntilFileExists(archiveFile(1));
sampleUntilFileExists(archiveFile(2));
@@ -118,6 +136,9 @@ public class DiskSpaceLimitIntegrationTest {
@Test
public void aboveZeroDeletesOldestFile() throws Exception {
+ this.dirOfDeletedFiles = this.temporaryFolder.newFolder("deleted");
+ this.sampleCollector.initialize(this.config, this.initTimeStamp, this.testRollingFileHandler);
+
when(this.config.getArchiveDiskSpaceLimit()).thenReturn(DISK_SPACE_LIMIT);
sampleUntilFileExists(archiveFile(1));
sampleUntilFileExists(archiveFile(2));
@@ -138,6 +159,118 @@ public class DiskSpaceLimitIntegrationTest {
assertThat(everExisted(archiveFile(1))).isTrue();
}
+ @Test
+ public void aboveZeroDeletesPreviousFiles() throws Exception {
+ assertThat(numberOfFiles(this.dir)).as("Unexpected files: " + listFiles(this.dir)).isEqualTo(0);
+
+ int oldMainId = 1;
+ int newMainId = 2;
+
+ int numberOfPreviousFiles = 100;
+ int numberOfLines = 100;
+ createPreviousFiles(oldMainId, numberOfPreviousFiles, numberOfLines);
+ assertThat(numberOfFiles(this.dir)).as("Missing files: " + listFiles(this.dir))
+ .isEqualTo(numberOfPreviousFiles);
+
+ for (int childId = 1; childId <= numberOfPreviousFiles; childId++) {
+ assertThat(archiveFile(oldMainId, childId)).exists();
+ }
+
+ // current archive file does not exist yet
+ assertThat(archiveFile()).doesNotExist();
+
+ // rolling files for mainId 2 do not exist yet
+ assertThat(markerFile(newMainId)).doesNotExist();
+ assertThat(archiveFile(newMainId, 1)).doesNotExist();
+
+ when(this.config.getArchiveDiskSpaceLimit())
+ .thenReturn(sizeOfDirectory(this.dir) / numberOfPreviousFiles);
+
+ this.sampleCollector.initialize(this.config, this.initTimeStamp,
+ this.mainWithChildrenRollingFileHandler);
+
+ assertThat(archiveFile()).exists().hasParent(this.dir);
+ assertThat(markerFile(newMainId)).exists().hasParent(this.dir).hasBinaryContent(new byte[0]);
+
+ assertThat(archiveFile(newMainId, 1)).doesNotExist();
+
+ sampleNumberOfTimes(1);
+
+ sampleUntilFileExists(archiveFile(newMainId, 1));
+ assertThat(archiveFile(newMainId, 1)).exists();
+
+ // this might be a brittle assertion... ok to delete if following for-block-assertion passes
+ assertThat(numberOfFiles(this.dir)).as("Unexpected files: " + listFiles(this.dir)).isEqualTo(2);
+
+ for (int childId = 1; childId <= numberOfPreviousFiles; childId++) {
+ assertThat(archiveFile(oldMainId, childId)).doesNotExist();
+ }
+ }
+
+ @Test
+ public void aboveZeroDeletesPreviousFiles_nameWithHyphen() throws Exception {
+ this.name = "psin8p724_cache1-statistics";
+ this.archiveFileName = new File(this.dir, this.name + ".gfs").getAbsolutePath();
+ when(this.config.getArchiveFileName()).thenReturn(new File(this.archiveFileName));
+
+ assertThat(numberOfFiles(this.dir)).as("Unexpected files: " + listFiles(this.dir)).isEqualTo(0);
+
+ int oldMainId = 1;
+ int newMainId = 2;
+
+ int numberOfPreviousFiles = 100;
+ int numberOfLines = 100;
+ createPreviousFiles(oldMainId, numberOfPreviousFiles, numberOfLines);
+ assertThat(numberOfFiles(this.dir)).as("Missing files: " + listFiles(this.dir))
+ .isEqualTo(numberOfPreviousFiles);
+
+ for (int childId = 1; childId <= numberOfPreviousFiles; childId++) {
+ assertThat(archiveFile(oldMainId, childId)).exists();
+ }
+
+ // current archive file does not exist yet
+ assertThat(archiveFile()).doesNotExist();
+
+ // rolling files for mainId 2 do not exist yet
+ assertThat(markerFile(newMainId)).doesNotExist();
+ assertThat(archiveFile(newMainId, 1)).doesNotExist();
+
+ when(this.config.getArchiveDiskSpaceLimit())
+ .thenReturn(sizeOfDirectory(this.dir) / numberOfPreviousFiles);
+
+ this.sampleCollector.initialize(this.config, this.initTimeStamp,
+ this.mainWithChildrenRollingFileHandler);
+
+ assertThat(archiveFile()).exists().hasParent(this.dir);
+ assertThat(markerFile(newMainId)).exists().hasParent(this.dir).hasBinaryContent(new byte[0]);
+
+ assertThat(archiveFile(newMainId, 1)).doesNotExist();
+
+ sampleNumberOfTimes(1);
+
+ sampleUntilFileExists(archiveFile(newMainId, 1));
+ assertThat(archiveFile(newMainId, 1)).exists();
+
+ // this might be a brittle assertion... ok to delete if following for-block-assertion passes
+ assertThat(numberOfFiles(this.dir)).as("Unexpected files: " + listFiles(this.dir)).isEqualTo(2);
+
+ for (int childId = 1; childId <= numberOfPreviousFiles; childId++) {
+ assertThat(archiveFile(oldMainId, childId)).doesNotExist();
+ }
+ }
+
+ private void sampleNumberOfTimes(final int value) throws InterruptedException {
+ long minutes = 1;
+ long timeout = System.nanoTime() + MINUTES.toNanos(minutes);
+ int count = 0;
+ do {
+ sample(advanceNanosTimeStamp());
+ count++;
+ Thread.sleep(10);
+ } while (count < value && System.nanoTime() < timeout);
+ System.out.println("Sampled " + count + " times.");
+ }
+
private void sampleUntilFileExists(final File file)
throws InterruptedException, TimeoutException {
long minutes = 1;
@@ -203,9 +336,102 @@ public class DiskSpaceLimitIntegrationTest {
return 1000; // 1 second
}
- private File archiveFile(final int child) {
- return new File(this.dir,
- this.testName.getMethodName() + "-01-" + String.format("%02d", child) + ".gfs");
+ private File archiveFile() {
+ return archiveFile(archiveName());
+ }
+
+ private String archiveName() {
+ return this.name;
+ }
+
+ private File archiveFile(final String name) {
+ return new File(this.dir, name + ".gfs");
+ }
+
+ private File archiveFile(final int childId) {
+ return archiveFile(1, childId);
+ }
+
+ private File archiveFile(final int mainId, final int childId) {
+ return archiveFile(archiveName(), mainId, childId);
+ }
+
+ private File archiveFile(final String name, final int mainId, final int childId) {
+ return new File(this.dir, archiveName(name, mainId, childId) + ".gfs");
+ }
+
+ private String archiveName(final int mainId, final int childId) {
+ return archiveName(archiveName(), mainId, childId);
+ }
+
+ private String archiveName(final String name, final int mainId, final int childId) {
+ return name + "-" + formatId(mainId) + "-" + formatId(childId);
+ }
+
+ private File markerFile(final int mainId) {
+ return markerFile(archiveName(), mainId);
+ }
+
+ private File markerFile(final String name, final int mainId) {
+ return new File(this.dir, markerName(name, mainId));
+ }
+
+ private String markerName(final int mainId) {
+ return markerName(archiveName(), mainId);
+ }
+
+ private String markerName(final String name, final int mainId) {
+ return archiveName(name, mainId, 0) + ".marker";
+ }
+
+ private String formatId(final int id) {
+ return String.format("%02d", id);
+ }
+
+ private List<File> listFiles(final File dir) {
+ return Arrays.asList(dir.listFiles());
+ }
+
+ private int numberOfFiles(final File dir) {
+ return dir.listFiles().length;
+ }
+
+ private void createPreviousFiles(final int mainId, final int fileCount, final int lineCount)
+ throws IOException {
+ createPreviousFiles(this.name, mainId, fileCount, lineCount);
+ }
+
+ private void createPreviousFiles(final String name, final int mainId, final int fileCount,
+ final int lineCount) throws IOException {
+ int childId = 1;
+ List<String> lines = lines(lineCount);
+ for (int i = 0; i < fileCount; i++) {
+ File file = createFile(name, mainId, childId);
+ writeFile(file, lines);
+ childId++;
+ }
+ }
+
+ private File createFile(final String name, final int mainId, final int childId) {
+ File file = new File(this.dir, name + "-" + leftPad(valueOf(mainId), 2, "0") + "-"
+ + leftPad(valueOf(childId), 2, "0") + ".gfs");
+ return file;
+ }
+
+ private void writeFile(final File file, final List<String> lines) throws IOException {
+ PrintWriter writer = new PrintWriter(file, "UTF-8");
+ for (String line : lines) {
+ writer.println(line);
+ }
+ writer.close();
+ }
+
+ private List<String> lines(final int lineCount) {
+ List<String> lines = new ArrayList<>();
+ for (int i = 0; i < lineCount; i++) {
+ lines.add(this.testName.getMethodName());
+ }
+ return lines;
}
/**
@@ -222,5 +448,4 @@ public class DiskSpaceLimitIntegrationTest {
}
}
}
-
}
http://git-wip-us.apache.org/repos/asf/geode/blob/76fa7cc7/geode-core/src/test/java/org/apache/geode/internal/statistics/StatArchiveHandlerIntegrationTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/internal/statistics/StatArchiveHandlerIntegrationTest.java b/geode-core/src/test/java/org/apache/geode/internal/statistics/StatArchiveHandlerIntegrationTest.java
new file mode 100644
index 0000000..ca5993c
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/internal/statistics/StatArchiveHandlerIntegrationTest.java
@@ -0,0 +1,243 @@
+/*
+ * 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.
+ */
+package org.apache.geode.internal.statistics;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+
+import java.io.File;
+import java.io.IOException;
+
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.TemporaryFolder;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+
+import org.apache.geode.internal.io.MainWithChildrenRollingFileHandler;
+import org.apache.geode.internal.io.RollingFileHandler;
+import org.apache.geode.test.junit.categories.IntegrationTest;
+
+/**
+ * Tests behavior that interacts with file system.
+ */
+@Category(IntegrationTest.class)
+@RunWith(JUnitParamsRunner.class)
+public class StatArchiveHandlerIntegrationTest {
+
+ private File dir;
+ private String ext;
+ private String name;
+ private File archive;
+
+ private StatArchiveHandlerConfig mockConfig;
+ private SampleCollector mockCollector;
+ private RollingFileHandler rollingFileHandler;
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ @Rule
+ public TestName testName = new TestName();
+
+ @Before
+ public void setUp() throws Exception {
+ this.dir = this.temporaryFolder.getRoot();
+
+ this.ext = ".gfs";
+ this.name = this.testName.getMethodName();
+ this.archive = new File(this.dir, this.name + this.ext);
+
+ this.mockConfig = mock(StatArchiveHandlerConfig.class);
+ this.mockCollector = mock(SampleCollector.class);
+ this.rollingFileHandler = new MainWithChildrenRollingFileHandler();
+ }
+
+ @Test
+ @Parameters({"false,false,false", "false,false,true", "false,true,false", "false,true,true",
+ "true,false,false", "true,false,true", "true,true,false", "true,true,true"})
+ public void getRollingArchiveName_withEmptyDir_createsFirstIds(final boolean archiveExists,
+ final boolean archiveClosed, final boolean initMainId) throws Exception {
+ if (archiveExists) {
+ this.archive.createNewFile();
+ }
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ if (initMainId) {
+ handler.initMainArchiveId(this.archive);
+ }
+
+ File file = handler.getRollingArchiveName(this.archive, archiveClosed);
+
+ assertThat(file).hasParent(this.dir).hasName(this.name + formatIds(1, 1) + this.ext);
+ }
+
+ @Test
+ @Parameters({"1,1,false,false", "1,1,false,true", "1,1,true,false", "1,1,true,true",
+ "1,10,false,false", "1,10,false,true", "1,10,true,false", "1,10,true,true",
+ "10,1,false,false", "10,1,false,true", "10,1,true,false", "10,1,true,true",
+ "10,10,false,false", "10,10,false,true", "10,10,true,false", "10,10,true,true"})
+ public void getRollingArchiveName_withOldArchives_rollsChildId(final int mainCount,
+ final int childCount, final boolean archiveExists, final boolean archiveClosed)
+ throws Exception {
+ createEmptyArchiveFiles(this.dir, this.name, this.ext, mainCount, childCount);
+ if (archiveExists) {
+ this.archive.createNewFile();
+ }
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+
+ File file = handler.getRollingArchiveName(this.archive, archiveClosed);
+
+ assertThat(file).hasParent(this.dir)
+ .hasName(this.name + formatIds(mainCount, childCount + 1) + this.ext);
+ }
+
+ @Test
+ public void initMainArchiveId_withEmptyDir_createsMainId_createsFirstMarker() throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+
+ handler.initMainArchiveId(this.archive);
+
+ assertThat(new File(this.dir, this.name + formatIds(1, 0) + ".marker")).exists();
+ }
+
+ @Test
+ @Parameters({"1,1", "1,10", "10,1", "10,10"})
+ public void initMainArchiveId_withOldArchives_rollsMainId_rollsMarker(final int mainCount,
+ final int childCount) throws Exception {
+ createEmptyArchiveFiles(this.dir, this.name, this.ext, mainCount, childCount);
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+
+ handler.initMainArchiveId(this.archive);
+
+ assertThat(new File(this.dir, this.name + formatIds(mainCount + 1, 0) + ".marker")).exists();
+ }
+
+ @Test
+ public void getRenameArchiveName_withEmptyDir_createsFirstIds() throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).isNotNull().isEqualTo(new File(this.dir, this.name + "-01-01" + this.ext));
+ }
+
+ @Test
+ public void getRenameArchiveName_withExtraneousIds_withEmptyDir_appendsIds() throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ this.archive = new File(this.dir, this.name + "-01-01" + this.ext);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).hasParent(this.dir).hasName(this.name + "-01-01-01-01" + this.ext);
+ }
+
+ @Test
+ public void getRenameArchiveName_withExtraneousDots_withEmptyDir_appendsIds() throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ this.archive = new File(this.dir, this.name + ".test.test" + this.ext);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).hasParent(this.dir).hasName(this.name + ".test.test-01-01" + this.ext);
+ }
+
+ @Test
+ public void getRenameArchiveName_withExtraneousUnderscores_withEptyDir_appendsIds()
+ throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ this.archive = new File(this.dir, this.name + "_test_test" + this.ext);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).hasParent(this.dir).hasName(this.name + "_test_test-01-01" + this.ext);
+ }
+
+ @Test
+ public void getRenameArchiveName_withExtraneousHyphens_withEmptyDir_appendsIds()
+ throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ this.archive = new File(this.dir, this.name + "-test-test" + this.ext);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).hasParent(this.dir).hasName(this.name + "-test-test-01-01" + this.ext);
+ }
+
+ @Test
+ @Parameters({"1,1", "1,10", "10,1", "10,10"})
+ public void getRenameArchiveName_withOldArchives_rollsMainId(final int mainCount,
+ final int childCount) throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ createEmptyArchiveFiles(this.dir, this.name, this.ext, mainCount, childCount);
+
+ File renamed = handler.getRenameArchiveName(this.archive);
+
+ assertThat(renamed).doesNotExist().hasParent(this.dir)
+ .hasName(this.name + formatIds(mainCount + 1, 1) + this.ext);
+ }
+
+ @Test
+ public void getRenameArchiveName_withNullArchive_throwsNullPointerException() throws Exception {
+ StatArchiveHandler handler =
+ new StatArchiveHandler(this.mockConfig, this.mockCollector, this.rollingFileHandler);
+ File archive = null;
+
+ assertThatThrownBy(() -> handler.getRenameArchiveName(archive))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ /**
+ * Returns mainId and childId formatted like "-01-01"
+ */
+ private String formatIds(final int mainId, final int childId) {
+ return "-" + formatId(mainId) + "-" + formatId(childId);
+ }
+
+ /**
+ * Returns id formatted like "01"
+ */
+ private String formatId(final int id) {
+ return String.format("%02d", id);
+ }
+
+ /**
+ * Creates empty archive files like dir/name-mainId-childId.ext. Returns greatest mainId.
+ */
+ private int createEmptyArchiveFiles(final File dir, final String name, final String ext,
+ final int mainCount, final int childCount) throws IOException {
+ int mainId = 1;
+ for (; mainId <= mainCount; mainId++) {
+ for (int childId = 1; childId <= childCount; childId++) {
+ File existing = new File(dir, name + formatIds(mainId, childId) + ext);
+ existing.createNewFile();
+ }
+ }
+ return mainId - 1;
+ }
+}
[3/5] geode git commit: GEODE-2520: Add a lucene query test where a
bucket is moved while a query is executing
Posted by kl...@apache.org.
GEODE-2520: Add a lucene query test where a bucket is moved while a query is executing
* Added LuceneIndexServiceSpy
Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/0d2397b2
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/0d2397b2
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/0d2397b2
Branch: refs/heads/feature/GEODE-2460
Commit: 0d2397b203060f02b95ece30bf4c7130685b71cd
Parents: 8065b67
Author: Jason Huynh <hu...@gmail.com>
Authored: Fri Feb 17 13:03:29 2017 -0800
Committer: Jason Huynh <hu...@gmail.com>
Committed: Wed Feb 22 11:33:59 2017 -0800
----------------------------------------------------------------------
.../internal/distributed/LuceneFunction.java | 1 +
.../distributed/WaitUntilFlushedFunction.java | 10 ++-
.../geode/cache/lucene/LuceneQueriesPRBase.java | 32 +++++++-
.../lucene/internal/LuceneIndexFactorySpy.java | 80 ++++++++++++++++++++
4 files changed, 116 insertions(+), 7 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/geode/blob/0d2397b2/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/LuceneFunction.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/LuceneFunction.java b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/LuceneFunction.java
index 76c5893..a4c2c66 100644
--- a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/LuceneFunction.java
+++ b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/LuceneFunction.java
@@ -22,6 +22,7 @@ import java.util.Collection;
import org.apache.geode.cache.execute.Function;
import org.apache.geode.cache.lucene.internal.LuceneIndexImpl;
import org.apache.geode.cache.lucene.internal.LuceneIndexStats;
+import org.apache.geode.internal.cache.execute.InternalFunctionInvocationTargetException;
import org.apache.logging.log4j.Logger;
import org.apache.lucene.search.Query;
http://git-wip-us.apache.org/repos/asf/geode/blob/0d2397b2/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/WaitUntilFlushedFunction.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/WaitUntilFlushedFunction.java b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/WaitUntilFlushedFunction.java
index 90f1b9f..e11384c 100644
--- a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/WaitUntilFlushedFunction.java
+++ b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/distributed/WaitUntilFlushedFunction.java
@@ -20,6 +20,8 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.execute.Function;
import org.apache.geode.cache.lucene.internal.LuceneIndexImpl;
import org.apache.geode.cache.lucene.internal.LuceneIndexStats;
import org.apache.geode.cache.lucene.internal.LuceneServiceImpl;
@@ -49,7 +51,7 @@ import org.apache.geode.internal.logging.LogService;
* in current AEQs are flushed into index. This function enables an accessor and client to call to
* make sure the current events are processed.
*/
-public class WaitUntilFlushedFunction extends FunctionAdapter implements InternalEntity {
+public class WaitUntilFlushedFunction implements Function, InternalEntity {
private static final long serialVersionUID = 1L;
public static final String ID = WaitUntilFlushedFunction.class.getName();
@@ -61,7 +63,7 @@ public class WaitUntilFlushedFunction extends FunctionAdapter implements Interna
ResultSender<Boolean> resultSender = ctx.getResultSender();
Region region = ctx.getDataSet();
-
+ Cache cache = region.getCache();
WaitUntilFlushedFunctionContext arg = (WaitUntilFlushedFunctionContext) ctx.getArguments();
String indexName = arg.getIndexName();
if (indexName == null) {
@@ -70,12 +72,12 @@ public class WaitUntilFlushedFunction extends FunctionAdapter implements Interna
long timeout = arg.getTimeout();
TimeUnit unit = arg.getTimeunit();
- LuceneService service = LuceneServiceProvider.get(region.getCache());
+ LuceneService service = LuceneServiceProvider.get(cache);
LuceneIndexImpl index = (LuceneIndexImpl) service.getIndex(indexName, region.getFullPath());
boolean result = false;
String aeqId = LuceneServiceImpl.getUniqueIndexName(indexName, region.getFullPath());
- AsyncEventQueueImpl queue = (AsyncEventQueueImpl) region.getCache().getAsyncEventQueue(aeqId);
+ AsyncEventQueueImpl queue = (AsyncEventQueueImpl) cache.getAsyncEventQueue(aeqId);
if (queue != null) {
try {
result = queue.waitUntilFlushed(timeout, unit);
http://git-wip-us.apache.org/repos/asf/geode/blob/0d2397b2/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
index 25a4927..9c2f6ed 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
@@ -20,9 +20,13 @@ import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
import static org.junit.Assert.*;
import static org.mockito.Matchers.any;
-import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
+import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
import org.apache.geode.distributed.internal.DistributionManager;
import org.apache.geode.distributed.internal.DistributionMessage;
import org.apache.geode.distributed.internal.DistributionMessageObserver;
@@ -30,6 +34,11 @@ import org.apache.geode.internal.cache.InitialImageOperation;
import org.apache.geode.internal.cache.InitialImageOperation.GIITestHook;
import org.apache.geode.internal.cache.InitialImageOperation.GIITestHookType;
import org.apache.geode.internal.cache.InitialImageOperation.RequestImageMessage;
+import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
import org.junit.After;
import org.junit.Test;
@@ -37,10 +46,8 @@ import org.apache.geode.cache.Cache;
import org.apache.geode.cache.PartitionAttributes;
import org.apache.geode.cache.PartitionAttributesFactory;
import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.control.RebalanceOperation;
import org.apache.geode.cache.control.RebalanceResults;
-import org.apache.geode.cache.lucene.internal.LuceneIndexImpl;
import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.cache.partition.PartitionRegionHelper;
@@ -79,6 +86,15 @@ public abstract class LuceneQueriesPRBase extends LuceneQueriesBase {
}
@Test
+ public void returnCorrectResultsWhenMoveBucketHappensOnQuery() throws InterruptedException {
+ final DistributedMember member2 =
+ dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
+ addCallbackToMovePrimaryOnQuery(dataStore1, member2);
+
+ putEntriesAndValidateQueryResults();
+ }
+
+ @Test
public void returnCorrectResultsWhenBucketIsMovedAndMovedBackOnIndexUpdate()
throws InterruptedException {
final DistributedMember member1 =
@@ -186,9 +202,18 @@ public abstract class LuceneQueriesPRBase extends LuceneQueriesBase {
});
}
+ protected void addCallbackToMovePrimaryOnQuery(VM vm, final DistributedMember destination) {
+ vm.invoke(() -> {
+ LuceneIndexFactorySpy factorySpy = LuceneIndexFactorySpy.injectSpy();
+
+ factorySpy.setGetRespositoryConsumer(doOnce(key -> moveBucket(destination, key)));
+ });
+ }
+
private void moveBucket(final DistributedMember destination, final Object key) {
Region<Object, Object> region = getCache().getRegion(REGION_NAME);
DistributedMember source = getCache().getDistributedSystem().getDistributedMember();
+ System.out.println("WHAT");
PartitionRegionHelper.moveBucketByKey(region, source, destination, key);
}
@@ -196,6 +221,7 @@ public abstract class LuceneQueriesPRBase extends LuceneQueriesBase {
vm.invoke(() -> {
IndexRepositorySpy.remove();
InitialImageOperation.resetAllGIITestHooks();
+ LuceneIndexFactorySpy.remove();
});
}
http://git-wip-us.apache.org/repos/asf/geode/blob/0d2397b2/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/LuceneIndexFactorySpy.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/LuceneIndexFactorySpy.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/LuceneIndexFactorySpy.java
new file mode 100644
index 0000000..5c6d256
--- /dev/null
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/LuceneIndexFactorySpy.java
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ */
+package org.apache.geode.cache.lucene.internal;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doAnswer;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.lucene.internal.repository.RepositoryManager;
+import org.apache.geode.internal.cache.BucketNotFoundException;
+import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.mockito.Mockito;
+import org.mockito.stubbing.Answer;
+
+import java.util.function.Consumer;
+
+public class LuceneIndexFactorySpy extends LuceneIndexFactory {
+
+ public static LuceneIndexFactorySpy injectSpy() {
+ LuceneIndexFactorySpy factory = new LuceneIndexFactorySpy();
+ LuceneServiceImpl.luceneIndexFactory = factory;
+ return factory;
+ }
+
+ public static void remove() {
+ LuceneServiceImpl.luceneIndexFactory = new LuceneIndexFactory();
+ }
+
+
+ private Consumer<Object> getRepositoryConsumer = key -> {
+ };
+
+ @Override
+ public LuceneIndexImpl create(String indexName, String regionPath, GemFireCacheImpl cache) {
+ LuceneIndexForPartitionedRegion index =
+ Mockito.spy(new ExtendedLuceneIndexForPartitionedRegion(indexName, regionPath, cache));
+ return index;
+ }
+
+
+ public void setGetRespositoryConsumer(Consumer<Object> getRepositoryConsumer) {
+ this.getRepositoryConsumer = getRepositoryConsumer;
+ }
+
+
+ private class ExtendedLuceneIndexForPartitionedRegion extends LuceneIndexForPartitionedRegion {
+ public ExtendedLuceneIndexForPartitionedRegion(final String indexName, final String regionPath,
+ final Cache cache) {
+ super(indexName, regionPath, cache);
+ }
+
+ @Override
+ public RepositoryManager createRepositoryManager() {
+ RepositoryManager repositoryManagerSpy = Mockito.spy(super.createRepositoryManager());
+ Answer getRepositoryAnswer = invocation -> {
+ getRepositoryConsumer.accept(invocation.getArgumentAt(0, Object.class));
+ return invocation.callRealMethod();
+ };
+ try {
+ doAnswer(getRepositoryAnswer).when(repositoryManagerSpy).getRepositories(any());
+ } catch (BucketNotFoundException e) {
+ e.printStackTrace();
+ }
+ return repositoryManagerSpy;
+ }
+ }
+}
+
[2/5] geode git commit: GEODE-2522: Flattened heirarchy of Lucene
DUnit tests
Posted by kl...@apache.org.
GEODE-2522: Flattened heirarchy of Lucene DUnit tests
Project: http://git-wip-us.apache.org/repos/asf/geode/repo
Commit: http://git-wip-us.apache.org/repos/asf/geode/commit/a63b8302
Tree: http://git-wip-us.apache.org/repos/asf/geode/tree/a63b8302
Diff: http://git-wip-us.apache.org/repos/asf/geode/diff/a63b8302
Branch: refs/heads/feature/GEODE-2460
Commit: a63b8302a07475c1726c891152daa9f8947091a6
Parents: 0d2397b
Author: Jason Huynh <hu...@gmail.com>
Authored: Wed Feb 22 08:53:26 2017 -0800
Committer: Jason Huynh <hu...@gmail.com>
Committed: Wed Feb 22 11:33:59 2017 -0800
----------------------------------------------------------------------
.../geode/cache/lucene/LuceneDUnitTest.java | 130 +++++++++-
.../lucene/LuceneIndexCreationDUnitTest.java | 158 +++++++------
.../LuceneIndexCreationOnFixedPRDUnitTest.java | 14 +-
.../cache/lucene/LuceneQueriesAccessorBase.java | 212 +++++++++++++++++
.../geode/cache/lucene/LuceneQueriesBase.java | 233 ------------------
.../lucene/LuceneQueriesClientDUnitTest.java | 19 +-
.../cache/lucene/LuceneQueriesDUnitTest.java | 143 +++++++++++
.../geode/cache/lucene/LuceneQueriesPRBase.java | 236 -------------------
.../LuceneQueriesPeerFixedPRDUnitTest.java | 39 ---
.../lucene/LuceneQueriesPeerPRDUnitTest.java | 41 ----
.../LuceneQueriesPeerPROverflowDUnitTest.java | 46 ----
.../LuceneQueriesPeerPRPersistentDUnitTest.java | 41 ----
.../LuceneQueriesPeerPRRedundancyDUnitTest.java | 186 ---------------
.../geode/cache/lucene/RebalanceDUnitTest.java | 200 ++++++++++++++++
.../RebalanceWithRedundancyDUnitTest.java | 181 ++++++++++++++
.../cache/lucene/test/LuceneTestUtilities.java | 7 +-
16 files changed, 974 insertions(+), 912 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
index 9318b0e..31ffced 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneDUnitTest.java
@@ -1,7 +1,7 @@
/*
* 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
+ * 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
*
@@ -14,15 +14,31 @@
*/
package org.apache.geode.cache.lucene;
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.EvictionAction;
+import org.apache.geode.cache.EvictionAttributes;
+import org.apache.geode.cache.PartitionAttributes;
+import org.apache.geode.cache.PartitionAttributesFactory;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.RegionShortcut;
+import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.dunit.VM;
+
import org.apache.geode.test.dunit.cache.internal.JUnit4CacheTestCase;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
+
+
+
public abstract class LuceneDUnitTest extends JUnit4CacheTestCase {
protected VM dataStore1;
protected VM dataStore2;
+ protected static int NUM_BUCKETS = 10;
+
+
@Override
public void postSetUp() throws Exception {
Host host = Host.getHost(0);
@@ -30,5 +46,115 @@ public abstract class LuceneDUnitTest extends JUnit4CacheTestCase {
dataStore2 = host.getVM(1);
}
- protected abstract void initDataStore(SerializableRunnableIF createIndex) throws Exception;
+ protected void initDataStore(SerializableRunnableIF createIndex,
+ RegionTestableType regionTestType) throws Exception {
+ createIndex.run();
+ regionTestType.createRegion(getCache(), REGION_NAME);
+ }
+
+ // Needed to seperate due to client/server tests...
+ protected void initAccessor(SerializableRunnableIF createIndex, RegionTestableType regionTestType)
+ throws Exception {
+ initDataStore(createIndex, regionTestType);
+ }
+
+ protected RegionTestableType[] getListOfServerRegionTestTypes() {
+ return new RegionTestableType[] {RegionTestableType.PARTITION,
+ RegionTestableType.PARTITION_PERSISTENT, RegionTestableType.PARTITION_REDUNDANT,
+ RegionTestableType.PARTITION_OVERFLOW_TO_DISK, RegionTestableType.PARTITION_REDUNDANT};
+ }
+
+
+ protected Object[] getListOfClientServerTypes() {
+ return new Object[] {
+ new RegionTestableType[] {RegionTestableType.PARTITION_PROXY, RegionTestableType.PARTITION},
+ new RegionTestableType[] {RegionTestableType.PARTITION, RegionTestableType.PARTITION},
+ new RegionTestableType[] {RegionTestableType.PARTITION_PROXY_REDUNDANT,
+ RegionTestableType.PARTITION_REDUNDANT},
+ new RegionTestableType[] {RegionTestableType.PARTITION_PROXY_WITH_OVERFLOW,
+ RegionTestableType.PARTITION_OVERFLOW_TO_DISK},
+ new RegionTestableType[] {RegionTestableType.PARTITION_REDUNDANT,
+ RegionTestableType.PARTITION_REDUNDANT},
+ new RegionTestableType[] {RegionTestableType.PARTITION_OVERFLOW_TO_DISK,
+ RegionTestableType.PARTITION_OVERFLOW_TO_DISK},
+ new RegionTestableType[] {RegionTestableType.FIXED_PARTITION_ACCESSOR,
+ RegionTestableType.FIXED_PARTITION}};
+ }
+
+ protected final Object[] parameterCombiner(Object[] aValues, Object[] bValues) {
+ Object[] parameters = new Object[aValues.length * bValues.length];
+ for (int i = 0; i < aValues.length; i++) {
+ for (int j = 0; j < bValues.length; j++) {
+ parameters[i * bValues.length + j] = new Object[] {aValues[i], bValues[j]};
+ }
+ }
+ return parameters;
+ }
+
+ public enum RegionTestableType {
+ PARTITION(RegionShortcut.PARTITION, false),
+ PARTITION_PROXY(RegionShortcut.PARTITION_PROXY, true),
+ PARTITION_PERSISTENT(RegionShortcut.PARTITION_PERSISTENT, false),
+ PARTITION_REDUNDANT(RegionShortcut.PARTITION_REDUNDANT, false),
+ PARTITION_OVERFLOW_TO_DISK(RegionShortcut.PARTITION_OVERFLOW, false,
+ EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK)),
+ PARTITION_PROXY_WITH_OVERFLOW(RegionShortcut.PARTITION_PROXY, true,
+ EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK)),
+ FIXED_PARTITION(RegionShortcut.PARTITION, false),
+ FIXED_PARTITION_ACCESSOR(RegionShortcut.PARTITION, true),
+
+ PARTITION_PROXY_REDUNDANT(RegionShortcut.PARTITION_PROXY_REDUNDANT, true),
+ CLIENT_PARTITION(RegionShortcut.PARTITION, false),
+ CLIENT_PARTITION_PERSISTENT(RegionShortcut.PARTITION_PERSISTENT, false),
+ ACCESSOR_PARTITION_PERSISTENT(RegionShortcut.PARTITION_PERSISTENT, true);
+
+
+ EvictionAttributes evictionAttributes = null;
+ private RegionShortcut shortcut;
+ private boolean isAccessor;
+
+ RegionTestableType(RegionShortcut shortcut, boolean isAccessor) {
+ this(shortcut, isAccessor, null);
+ }
+
+ RegionTestableType(RegionShortcut shortcut, boolean isAccessor,
+ EvictionAttributes evictionAttributes) {
+ this.shortcut = shortcut;
+ this.isAccessor = isAccessor;
+ this.evictionAttributes = evictionAttributes;
+ }
+
+ public Region createRegion(Cache cache, String regionName) {
+ if (this.equals(CLIENT_PARTITION)) {
+ return null;
+ } else if (this.equals(FIXED_PARTITION_ACCESSOR)) {
+ return LuceneTestUtilities.createFixedPartitionedRegion(cache, regionName, null, 0);
+ } else if (this.equals(FIXED_PARTITION)) {
+ try {
+ return LuceneTestUtilities.initDataStoreForFixedPR(cache);
+ } catch (Exception e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+ if (evictionAttributes == null) {
+ return cache.createRegionFactory(shortcut)
+ .setPartitionAttributes(getPartitionAttributes(isAccessor)).create(regionName);
+ } else {
+ return cache.createRegionFactory(shortcut)
+ .setPartitionAttributes(getPartitionAttributes(isAccessor))
+ .setEvictionAttributes(evictionAttributes).create(regionName);
+ }
+ }
+ }
+
+ protected static PartitionAttributes getPartitionAttributes(final boolean isAccessor) {
+ PartitionAttributesFactory factory = new PartitionAttributesFactory();
+ if (!isAccessor) {
+ factory.setLocalMaxMemory(100);
+ }
+ factory.setTotalNumBuckets(NUM_BUCKETS);
+ return factory.create();
+ }
+
}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
index 6a02a25..71c111d 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationDUnitTest.java
@@ -14,7 +14,6 @@
*/
package org.apache.geode.cache.lucene;
-import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.junit.categories.DistributedTest;
@@ -42,32 +41,41 @@ import static org.junit.Assert.*;
@RunWith(JUnitParamsRunner.class)
public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
- @Override
- protected void initDataStore(SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION).create(REGION_NAME);
+ private final Object[] parametersForMultipleIndexCreates() {
+ Integer[] numIndexes = {1, 2, 10};
+ RegionTestableType[] regionTestTypes = getListOfServerRegionTestTypes();
+ return parameterCombiner(numIndexes, regionTestTypes);
}
+ protected final Object[] parametersForIndexAndRegions() {
+ Object[] indexCreations = new Object[] {getFieldsIndexWithOneField(),
+ getFieldsIndexWithTwoFields(), get2FieldsIndexes(), getAnalyzersIndexWithOneField(),
+ getAnalyzersIndexWithTwoFields(), getAnalyzersIndexWithNullField1()};
+ RegionTestableType[] regionTestTypes = getListOfServerRegionTestTypes();
+ return parameterCombiner(indexCreations, regionTestTypes);
+ }
@Test
- @Parameters({"1", "2", "10"})
- public void verifyThatIndexObjectsAreListedWhenPresentInTheSystem(int numberOfIndexes) {
+ @Parameters(method = "parametersForMultipleIndexCreates")
+ public void verifyThatIndexObjectsAreListedWhenPresentInTheSystem(int numberOfIndexes,
+ RegionTestableType regionType) {
SerializableRunnableIF createIndex = getMultipleIndexes(numberOfIndexes);
- dataStore1.invoke(() -> initDataStore(createIndex));
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
dataStore1.invoke(() -> verifyIndexList(numberOfIndexes));
- dataStore2.invoke(() -> initDataStore(createIndex));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
dataStore2.invoke(() -> verifyIndexList(numberOfIndexes));
}
@Test
- @Parameters({"1", "2", "10"})
- public void verifyThatIndexObjectIsRetrievedWhenPresentInTheSystem(int numberOfIndexes) {
+ @Parameters(method = "parametersForMultipleIndexCreates")
+ public void verifyThatIndexObjectIsRetrievedWhenPresentInTheSystem(int numberOfIndexes,
+ RegionTestableType regionType) {
SerializableRunnableIF createIndex = getMultipleIndexes(numberOfIndexes);
- dataStore1.invoke(() -> initDataStore(createIndex));
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
dataStore1.invoke(() -> verifyIndexes(numberOfIndexes));
- dataStore2.invoke(() -> initDataStore(createIndex));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
dataStore2.invoke(() -> verifyIndexes(numberOfIndexes));
}
@@ -108,132 +116,136 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
@Test
- public void verifyDifferentFieldsFails() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldsFails(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getFieldsIndexWithOneField();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getFieldsIndexWithTwoFields();
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS));
+ dataStore2.invoke(
+ () -> initDataStore(createIndex2, regionType, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS));
}
@Test
- public void verifyDifferentFieldAnalyzerSizesFails1() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldAnalyzerSizesFails1(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithTwoFields();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithOneField();
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS_2));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS_2));
}
@Test
- public void verifyDifferentFieldAnalyzerSizesFails2() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldAnalyzerSizesFails2(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithOneField();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithTwoFields();
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS));
+ dataStore2.invoke(
+ () -> initDataStore(createIndex2, regionType, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_FIELDS));
}
@Test
- public void verifyDifferentFieldAnalyzersFails1() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldAnalyzersFails1(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithOneField(StandardAnalyzer.class);
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithOneField(KeywordAnalyzer.class);
- dataStore2.invoke(
- () -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_2));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_2));
}
@Test
- public void verifyDifferentFieldAnalyzersFails2() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldAnalyzersFails2(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithNullField1();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithNullField2();
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS));
}
@Test
- public void verifyDifferentFieldAnalyzersFails3() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentFieldAnalyzersFails3(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithNullField2();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithNullField1();
- dataStore2.invoke(() -> initDataStore(createIndex2,
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
LuceneTestUtilities.CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_ANALYZERS_3));
}
@Test
- public void verifyDifferentIndexNamesFails() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentIndexNamesFails(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndex(INDEX_NAME + "1", REGION_NAME, "field1");
};
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndex(INDEX_NAME + "2", REGION_NAME, "field1");
};
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_NAMES));
+ dataStore2.invoke(
+ () -> initDataStore(createIndex2, regionType, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_NAMES));
}
@Test
- public void verifyDifferentIndexesFails1() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentIndexesFails1(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getFieldsIndexWithOneField();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = () -> {
/* Do nothing */};
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_1));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_1));
}
@Test
- public void verifyDifferentIndexesFails2() {
+ @Parameters({"PARTITION"})
+ public void verifyDifferentIndexesFails2(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getFieldsIndexWithOneField();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = () -> {
LuceneService luceneService = LuceneServiceProvider.get(getCache());
luceneService.createIndex(INDEX_NAME, REGION_NAME, "field1");
luceneService.createIndex(INDEX_NAME + "2", REGION_NAME, "field2");
};
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_2));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_2));
}
@Test
- public void verifyMemberWithoutIndexCreatedFirstFails() {
+ @Parameters({"PARTITION"})
+ public void verifyMemberWithoutIndexCreatedFirstFails(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = () -> {
/* Do nothing */};
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getFieldsIndexWithOneField();
- dataStore2
- .invoke(() -> initDataStore(createIndex2, CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_3));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType,
+ CANNOT_CREATE_LUCENE_INDEX_DIFFERENT_INDEXES_3));
}
@Test
- @Parameters(method = "getIndexes")
- public void verifySameIndexesSucceeds(SerializableRunnableIF createIndex) {
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
+ @Parameters(method = "parametersForIndexAndRegions")
+ public void verifySameIndexesSucceeds(SerializableRunnableIF createIndex,
+ RegionTestableType regionType) {
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
}
- protected final Object[] getIndexes() {
- return $(new Object[] {getFieldsIndexWithOneField()},
- new Object[] {getFieldsIndexWithTwoFields()}, new Object[] {get2FieldsIndexes()},
- new Object[] {getAnalyzersIndexWithOneField()},
- new Object[] {getAnalyzersIndexWithTwoFields()},
- new Object[] {getAnalyzersIndexWithNullField1()});
- }
@Test
@Parameters(method = "getXmlAndExceptionMessages")
@@ -295,21 +307,23 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
}
@Test
- public void verifyStandardAnalyzerAndNullOnSameFieldPasses() {
+ @Parameters("PARTITION")
+ public void verifyStandardAnalyzerAndNullOnSameFieldPasses(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithNullField1();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithTwoFields2();
- dataStore2.invoke(() -> initDataStore(createIndex2));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType));
}
@Test
- public void verifyStandardAnalyzerAndNullOnSameFieldPasses2() {
+ @Parameters("PARTITION")
+ public void verifyStandardAnalyzerAndNullOnSameFieldPasses2(RegionTestableType regionType) {
SerializableRunnableIF createIndex1 = getAnalyzersIndexWithTwoFields2();
- dataStore1.invoke(() -> initDataStore(createIndex1));
+ dataStore1.invoke(() -> initDataStore(createIndex1, regionType));
SerializableRunnableIF createIndex2 = getAnalyzersIndexWithNullField1();
- dataStore2.invoke(() -> initDataStore(createIndex2));
+ dataStore2.invoke(() -> initDataStore(createIndex2, regionType));
}
protected String getXmlFileForTest(String testName) {
@@ -321,11 +335,11 @@ public class LuceneIndexCreationDUnitTest extends LuceneDUnitTest {
return getClass().getSimpleName();
}
- protected void initDataStore(SerializableRunnableIF createIndex, String message)
- throws Exception {
+ protected void initDataStore(SerializableRunnableIF createIndex, RegionTestableType regionType,
+ String message) throws Exception {
createIndex.run();
try {
- getCache().createRegionFactory(RegionShortcut.PARTITION).create(REGION_NAME);
+ regionType.createRegion(getCache(), REGION_NAME);
fail("Should not have been able to create index");
} catch (IllegalStateException e) {
assertEquals(message, e.getMessage());
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationOnFixedPRDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationOnFixedPRDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationOnFixedPRDUnitTest.java
index 7de12e3..e623d7d 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationOnFixedPRDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneIndexCreationOnFixedPRDUnitTest.java
@@ -14,6 +14,7 @@
*/
package org.apache.geode.cache.lucene;
+import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.junit.categories.DistributedTest;
@@ -27,16 +28,17 @@ import junitparams.JUnitParamsRunner;
@Category(DistributedTest.class)
@RunWith(JUnitParamsRunner.class)
public class LuceneIndexCreationOnFixedPRDUnitTest extends LuceneIndexCreationDUnitTest {
+
@Override
- protected void initDataStore(SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- LuceneTestUtilities.initDataStoreForFixedPR(getCache());
+ protected RegionTestableType[] getListOfServerRegionTestTypes() {
+ return new RegionTestableType[] {RegionTestableType.FIXED_PARTITION};
}
- protected void initDataStore(SerializableRunnableIF createIndex, String message)
- throws Exception {
+ @Override
+ protected void initDataStore(SerializableRunnableIF createIndex, RegionTestableType regionType,
+ String message) throws Exception {
try {
- initDataStore(createIndex);
+ initDataStore(createIndex, regionType);
fail("Should not have been able to create index");
} catch (IllegalStateException e) {
assertEquals(message, e.getMessage());
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
new file mode 100644
index 0000000..00bb842
--- /dev/null
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesAccessorBase.java
@@ -0,0 +1,212 @@
+/*
+ * 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.
+ */
+package org.apache.geode.cache.lucene;
+
+
+import static org.apache.geode.cache.lucene.test.IndexRepositorySpy.doOnce;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.DEFAULT_FIELD;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.INDEX_NAME;
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.control.RebalanceOperation;
+import org.apache.geode.cache.control.RebalanceResults;
+import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
+import org.apache.geode.cache.lucene.internal.LuceneIndexImpl;
+import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
+import org.apache.geode.cache.partition.PartitionRegionHelper;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
+import org.apache.geode.internal.cache.InitialImageOperation;
+import org.apache.geode.internal.cache.PartitionedRegion;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
+import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
+import org.apache.geode.test.dunit.Host;
+import org.apache.geode.test.dunit.VM;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class LuceneQueriesAccessorBase extends LuceneDUnitTest {
+
+ protected VM accessor;
+
+ @Override
+ public void postSetUp() throws Exception {
+ super.postSetUp();
+ accessor = Host.getHost(0).getVM(3);
+ }
+
+ protected boolean waitForFlushBeforeExecuteTextSearch(VM vm, int ms) {
+ return vm.invoke(() -> {
+ Cache cache = getCache();
+
+ LuceneService service = LuceneServiceProvider.get(cache);
+ LuceneIndexImpl index = (LuceneIndexImpl) service.getIndex(INDEX_NAME, REGION_NAME);
+
+ return service.waitUntilFlushed(INDEX_NAME, REGION_NAME, ms, TimeUnit.MILLISECONDS);
+ });
+ }
+
+ protected void executeTextSearch(VM vm) {
+ vm.invoke(() -> {
+ Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
+
+ LuceneService service = LuceneServiceProvider.get(cache);
+ LuceneQuery<Integer, TestObject> query;
+ query = service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, "text:world",
+ DEFAULT_FIELD);
+ PageableLuceneQueryResults<Integer, TestObject> results = query.findPages();
+ assertEquals(3, results.size());
+ List<LuceneResultStruct<Integer, TestObject>> page = results.next();
+
+ Map<Integer, TestObject> data = new HashMap<Integer, TestObject>();
+ for (LuceneResultStruct<Integer, TestObject> row : page) {
+ data.put(row.getKey(), row.getValue());
+ }
+
+ assertEquals(new HashMap(region), data);
+ return null;
+ });
+ }
+
+ protected void executeTextSearch(VM vm, String queryString, String defaultField,
+ int expectedResultsSize) {
+ vm.invoke(() -> {
+ Cache cache = getCache();
+
+ LuceneService service = LuceneServiceProvider.get(cache);
+ LuceneQuery<Integer, TestObject> query;
+ query = service.createLuceneQueryFactory().setResultLimit(1000).setPageSize(1000)
+ .create(INDEX_NAME, REGION_NAME, queryString, defaultField);
+ Collection<?> results = query.findKeys();
+ System.out.println("JASON Lucene Query returned:" + results.size());
+
+ assertEquals(expectedResultsSize, results.size());
+ });
+ }
+
+ protected void addCallbackToTriggerRebalance(VM vm) {
+ vm.invoke(() -> {
+ IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
+
+ spy.beforeWriteIndexRepository(doOnce(key -> rebalanceRegion(vm)));
+ });
+ }
+
+ protected void addCallbackToMoveBucket(VM vm, final DistributedMember destination) {
+ vm.invoke(() -> {
+ IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
+
+ spy.beforeWriteIndexRepository(doOnce(key -> moveBucket(destination, key)));
+ });
+ }
+
+ protected void addCallbackToMovePrimary(VM vm, final DistributedMember destination) {
+ vm.invoke(() -> {
+ IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
+
+ spy.beforeWriteIndexRepository(doOnce(key -> movePrimary(destination, key)));
+ });
+ }
+
+ protected void addCallbackToMovePrimaryOnQuery(VM vm, final DistributedMember destination) {
+ vm.invoke(() -> {
+ LuceneIndexFactorySpy factorySpy = LuceneIndexFactorySpy.injectSpy();
+
+ factorySpy.setGetRespositoryConsumer(doOnce(key -> moveBucket(destination, key)));
+ });
+ }
+
+ private void moveBucket(final DistributedMember destination, final Object key) {
+ Region<Object, Object> region = getCache().getRegion(REGION_NAME);
+ DistributedMember source = getCache().getDistributedSystem().getDistributedMember();
+ PartitionRegionHelper.moveBucketByKey(region, source, destination, key);
+ }
+
+ private void movePrimary(final DistributedMember destination, final Object key) {
+ PartitionedRegion region = (PartitionedRegion) getCache().getRegion(REGION_NAME);
+
+ BecomePrimaryBucketResponse response =
+ BecomePrimaryBucketMessage.send((InternalDistributedMember) destination, region,
+ region.getKeyInfo(key).getBucketId(), true);
+ assertNotNull(response);
+ assertTrue(response.waitForResponse());
+ }
+
+ protected void removeCallback(VM vm) {
+ vm.invoke(() -> {
+ IndexRepositorySpy.remove();
+ InitialImageOperation.resetAllGIITestHooks();
+ LuceneIndexFactorySpy.remove();
+ });
+ }
+
+ protected void rebalanceRegion(VM vm) {
+ // Do a rebalance
+ vm.invoke(() -> {
+ RebalanceOperation op = getCache().getResourceManager().createRebalanceFactory().start();
+ RebalanceResults results = op.getResults();
+ });
+ }
+
+ protected static class TestObject implements Serializable {
+ private static final long serialVersionUID = 1L;
+ private String text;
+
+ public TestObject(String text) {
+ this.text = text;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((text == null) ? 0 : text.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ TestObject other = (TestObject) obj;
+ if (text == null) {
+ if (other.text != null)
+ return false;
+ } else if (!text.equals(other.text))
+ return false;
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return "TestObject[" + text + "]";
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesBase.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesBase.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesBase.java
deleted file mode 100644
index 1b1167c..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesBase.java
+++ /dev/null
@@ -1,233 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
-import static org.junit.Assert.*;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.lucene.internal.LuceneIndexImpl;
-import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
-import org.apache.geode.test.dunit.Host;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.dunit.VM;
-
-import org.apache.lucene.index.Term;
-import org.apache.lucene.search.TermQuery;
-import org.junit.Test;
-
-/**
- * This test class is intended to contain basic integration tests of the lucene query class that
- * should be executed against a number of different regions types and topologies.
- *
- */
-public abstract class LuceneQueriesBase extends LuceneDUnitTest {
-
- private static final long serialVersionUID = 1L;
- protected VM accessor;
-
- @Override
- public void postSetUp() throws Exception {
- super.postSetUp();
- accessor = Host.getHost(0).getVM(3);
- }
-
- protected abstract void initAccessor(SerializableRunnableIF createIndex) throws Exception;
-
- @Test
- public void returnCorrectResultsFromStringQueryWithDefaultAnalyzer() {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
-
- putDataInRegion(accessor);
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
- executeTextSearch(accessor);
- }
-
- @Test
- public void defaultFieldShouldPropogateCorrectlyThroughFunction() {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- putDataInRegion(accessor);
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
- executeTextSearch(accessor, "world", "text", 3);
- executeTextSearch(accessor, "world", "noEntriesMapped", 0);
- }
-
- @Test
- public void canQueryWithCustomLuceneQueryObject() {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- putDataInRegion(accessor);
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
-
- // Execute a query with a custom lucene query object
- accessor.invoke(() -> {
- Cache cache = getCache();
- LuceneService service = LuceneServiceProvider.get(cache);
- LuceneQuery query =
- service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, index -> {
- return new TermQuery(new Term("text", "world"));
- });
- final PageableLuceneQueryResults results = query.findPages();
- assertEquals(3, results.size());
- });
- }
-
- @Test
- public void verifyWaitForFlushedFunctionOnAccessor() throws InterruptedException {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- dataStore2.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- putDataInRegion(accessor);
- assertFalse(waitForFlushBeforeExecuteTextSearch(accessor, 200));
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- executeTextSearch(accessor, "world", "text", 3);
- executeTextSearch(accessor, "world", "noEntriesMapped", 0);
- }
-
- protected boolean waitForFlushBeforeExecuteTextSearch(VM vm, int ms) {
- return vm.invoke(() -> {
- Cache cache = getCache();
-
- LuceneService service = LuceneServiceProvider.get(cache);
- LuceneIndexImpl index = (LuceneIndexImpl) service.getIndex(INDEX_NAME, REGION_NAME);
-
- return service.waitUntilFlushed(INDEX_NAME, REGION_NAME, ms, TimeUnit.MILLISECONDS);
- });
- }
-
- protected void executeTextSearch(VM vm) {
- vm.invoke(() -> {
- Cache cache = getCache();
- Region<Object, Object> region = cache.getRegion(REGION_NAME);
-
- LuceneService service = LuceneServiceProvider.get(cache);
- LuceneQuery<Integer, TestObject> query;
- query = service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, "text:world",
- DEFAULT_FIELD);
- PageableLuceneQueryResults<Integer, TestObject> results = query.findPages();
- assertEquals(3, results.size());
- List<LuceneResultStruct<Integer, TestObject>> page = results.next();
-
- Map<Integer, TestObject> data = new HashMap<Integer, TestObject>();
- for (LuceneResultStruct<Integer, TestObject> row : page) {
- data.put(row.getKey(), row.getValue());
- }
-
- assertEquals(new HashMap(region), data);
- return null;
- });
- }
-
- protected void executeTextSearch(VM vm, String queryString, String defaultField,
- int expectedResultsSize) {
- vm.invoke(() -> {
- Cache cache = getCache();
-
- LuceneService service = LuceneServiceProvider.get(cache);
- LuceneQuery<Integer, TestObject> query;
- query = service.createLuceneQueryFactory().setResultLimit(1000).setPageSize(1000)
- .create(INDEX_NAME, REGION_NAME, queryString, defaultField);
- Collection<?> results = query.findKeys();
-
- assertEquals(expectedResultsSize, results.size());
- });
- }
-
- protected void putDataInRegion(VM vm) {
- vm.invoke(() -> {
- final Cache cache = getCache();
- Region<Object, Object> region = cache.getRegion(REGION_NAME);
- region.put(1, new TestObject("hello world"));
- region.put(113, new TestObject("hi world"));
- region.put(2, new TestObject("goodbye world"));
- });
- }
-
- protected static class TestObject implements Serializable {
- private static final long serialVersionUID = 1L;
- private String text;
-
- public TestObject(String text) {
- this.text = text;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((text == null) ? 0 : text.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj)
- return true;
- if (obj == null)
- return false;
- if (getClass() != obj.getClass())
- return false;
- TestObject other = (TestObject) obj;
- if (text == null) {
- if (other.text != null)
- return false;
- } else if (!text.equals(other.text))
- return false;
- return true;
- }
-
- @Override
- public String toString() {
- return "TestObject[" + text + "]";
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
index 36ede16..0753adf 100755
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesClientDUnitTest.java
@@ -27,9 +27,13 @@ import org.apache.geode.cache.server.CacheServer;
import org.apache.geode.test.dunit.SerializableCallableIF;
import org.apache.geode.test.dunit.SerializableRunnableIF;
import org.apache.geode.test.junit.categories.DistributedTest;
+import org.junit.runner.RunWith;
+
+import junitparams.JUnitParamsRunner;
@Category(DistributedTest.class)
-public class LuceneQueriesClientDUnitTest extends LuceneQueriesBase {
+@RunWith(JUnitParamsRunner.class)
+public class LuceneQueriesClientDUnitTest extends LuceneQueriesDUnitTest {
@Override
public void postSetUp() throws Exception {
@@ -53,13 +57,14 @@ public class LuceneQueriesClientDUnitTest extends LuceneQueriesBase {
});
}
- @Override
- protected void initAccessor(SerializableRunnableIF createIndex) throws Exception {}
+ protected void initAccessor(SerializableRunnableIF createIndex, RegionTestableType regionTestType)
+ throws Exception {}
- @Override
- protected void initDataStore(SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION).create(REGION_NAME);
+ protected Object[] getListOfClientServerTypes() {
+ return new Object[] {new RegionTestableType[] {RegionTestableType.CLIENT_PARTITION,
+ RegionTestableType.PARTITION}};
}
+
+
}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
new file mode 100644
index 0000000..f32bc84
--- /dev/null
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesDUnitTest.java
@@ -0,0 +1,143 @@
+/*
+ * 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.
+ */
+package org.apache.geode.cache.lucene;
+
+import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
+import static org.junit.Assert.*;
+
+import org.apache.geode.cache.Cache;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
+import org.apache.geode.test.dunit.SerializableRunnableIF;
+import org.apache.geode.test.dunit.VM;
+
+import org.apache.geode.test.junit.categories.DistributedTest;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.TermQuery;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
+
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+
+/**
+ * This test class is intended to contain basic integration tests of the lucene query class that
+ * should be executed against a number of different regions types and topologies.
+ *
+ */
+@Category(DistributedTest.class)
+@RunWith(JUnitParamsRunner.class)
+public class LuceneQueriesDUnitTest extends LuceneQueriesAccessorBase {
+
+ private static final long serialVersionUID = 1L;
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void returnCorrectResultsFromStringQueryWithDefaultAnalyzer(RegionTestableType clientType,
+ RegionTestableType regionType) {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+ executeTextSearch(accessor);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void defaultFieldShouldPropogateCorrectlyThroughFunction(RegionTestableType clientType,
+ RegionTestableType regionType) {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+ executeTextSearch(accessor, "world", "text", 3);
+ executeTextSearch(accessor, "world", "noEntriesMapped", 0);
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void canQueryWithCustomLuceneQueryObject(RegionTestableType clientType,
+ RegionTestableType regionType) {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ putDataInRegion(accessor);
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
+
+ // Execute a query with a custom lucene query object
+ accessor.invoke(() -> {
+ Cache cache = getCache();
+ LuceneService service = LuceneServiceProvider.get(cache);
+ LuceneQuery query =
+ service.createLuceneQueryFactory().create(INDEX_NAME, REGION_NAME, index -> {
+ return new TermQuery(new Term("text", "world"));
+ });
+ final PageableLuceneQueryResults results = query.findPages();
+ assertEquals(3, results.size());
+ });
+ }
+
+ @Test
+ @Parameters(method = "getListOfClientServerTypes")
+ public void verifyWaitForFlushedFunctionOnAccessor(RegionTestableType clientType,
+ RegionTestableType regionType) throws InterruptedException {
+ SerializableRunnableIF createIndex = () -> {
+ LuceneService luceneService = LuceneServiceProvider.get(getCache());
+ luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
+ };
+ dataStore1.invoke(() -> initDataStore(createIndex, regionType));
+ dataStore2.invoke(() -> initDataStore(createIndex, regionType));
+ accessor.invoke(() -> initAccessor(createIndex, clientType));
+ dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+ dataStore2.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
+ putDataInRegion(accessor);
+ assertFalse(waitForFlushBeforeExecuteTextSearch(accessor, 200));
+ dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
+ assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
+ executeTextSearch(accessor, "world", "text", 3);
+ executeTextSearch(accessor, "world", "noEntriesMapped", 0);
+ }
+
+ protected void putDataInRegion(VM vm) {
+ vm.invoke(() -> {
+ final Cache cache = getCache();
+ Region<Object, Object> region = cache.getRegion(REGION_NAME);
+ region.put(1, new TestObject("hello world"));
+ region.put(113, new TestObject("hi world"));
+ region.put(2, new TestObject("goodbye world"));
+ });
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
deleted file mode 100644
index 9c2f6ed..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPRBase.java
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * 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.
- */
-
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.IndexRepositorySpy.doOnce;
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.any;
-
-import java.util.stream.IntStream;
-
-import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
-import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
-import org.apache.geode.internal.cache.PartitionedRegion;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
-import org.apache.geode.distributed.internal.DistributionManager;
-import org.apache.geode.distributed.internal.DistributionMessage;
-import org.apache.geode.distributed.internal.DistributionMessageObserver;
-import org.apache.geode.internal.cache.InitialImageOperation;
-import org.apache.geode.internal.cache.InitialImageOperation.GIITestHook;
-import org.apache.geode.internal.cache.InitialImageOperation.GIITestHookType;
-import org.apache.geode.internal.cache.InitialImageOperation.RequestImageMessage;
-import org.apache.geode.cache.lucene.internal.LuceneIndexFactorySpy;
-import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
-import org.apache.geode.internal.cache.PartitionedRegion;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
-import org.junit.After;
-import org.junit.Test;
-
-import org.apache.geode.cache.Cache;
-import org.apache.geode.cache.PartitionAttributes;
-import org.apache.geode.cache.PartitionAttributesFactory;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.control.RebalanceOperation;
-import org.apache.geode.cache.control.RebalanceResults;
-import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
-import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
-import org.apache.geode.cache.partition.PartitionRegionHelper;
-import org.apache.geode.distributed.DistributedMember;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.dunit.VM;
-
-/**
- * This test class adds more basic tests of lucene functionality for partitioned regions. These
- * tests should work across all types of PRs and topologies.
- *
- */
-public abstract class LuceneQueriesPRBase extends LuceneQueriesBase {
- protected static final int NUM_BUCKETS = 10;
-
- @After
- public void cleanupRebalanceCallback() {
- removeCallback(dataStore1);
- removeCallback(dataStore2);
- }
-
- @Test
- public void returnCorrectResultsWhenRebalanceHappensOnIndexUpdate() throws InterruptedException {
- addCallbackToTriggerRebalance(dataStore1);
-
- putEntriesAndValidateQueryResults();
- }
-
- @Test
- public void returnCorrectResultsWhenMoveBucketHappensOnIndexUpdate() throws InterruptedException {
- final DistributedMember member2 =
- dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- addCallbackToMoveBucket(dataStore1, member2);
-
- putEntriesAndValidateQueryResults();
- }
-
- @Test
- public void returnCorrectResultsWhenMoveBucketHappensOnQuery() throws InterruptedException {
- final DistributedMember member2 =
- dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- addCallbackToMovePrimaryOnQuery(dataStore1, member2);
-
- putEntriesAndValidateQueryResults();
- }
-
- @Test
- public void returnCorrectResultsWhenBucketIsMovedAndMovedBackOnIndexUpdate()
- throws InterruptedException {
- final DistributedMember member1 =
- dataStore1.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- final DistributedMember member2 =
- dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- addCallbackToMoveBucket(dataStore1, member2);
- addCallbackToMoveBucket(dataStore2, member1);
-
- putEntriesAndValidateQueryResults();
- }
-
- @Test
- public void returnCorrectResultsWhenRebalanceHappensAfterUpdates() throws InterruptedException {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
-
- putEntryInEachBucket();
-
- dataStore2.invoke(() -> initDataStore(createIndex));
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
-
- rebalanceRegion(dataStore2);
-
- executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
- }
-
- @Test
- public void returnCorrectResultsWhenRebalanceHappensWhileSenderIsPaused()
- throws InterruptedException {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
-
- putEntryInEachBucket();
-
- dataStore2.invoke(() -> initDataStore(createIndex));
- rebalanceRegion(dataStore2);
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
-
- assertTrue(waitForFlushBeforeExecuteTextSearch(accessor, 60000));
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
-
- executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
- }
-
- protected PartitionAttributes getPartitionAttributes(final boolean isAccessor) {
- PartitionAttributesFactory factory = new PartitionAttributesFactory();
- if (!isAccessor) {
- factory.setLocalMaxMemory(100);
- }
- factory.setTotalNumBuckets(NUM_BUCKETS);
- return factory.create();
- }
-
- protected void putEntriesAndValidateQueryResults() {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
-
- putEntryInEachBucket();
-
- dataStore2.invoke(() -> initDataStore(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
-
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 60000));
-
- executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
- }
-
- protected void putEntryInEachBucket() {
- accessor.invoke(() -> {
- final Cache cache = getCache();
- Region<Object, Object> region = cache.getRegion(REGION_NAME);
- IntStream.range(0, NUM_BUCKETS).forEach(i -> region.put(i, new TestObject("hello world")));
- });
- }
-
- private void addCallbackToTriggerRebalance(VM vm) {
- vm.invoke(() -> {
- IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
-
- spy.beforeWriteIndexRepository(doOnce(key -> rebalanceRegion(vm)));
- });
- }
-
- protected void addCallbackToMoveBucket(VM vm, final DistributedMember destination) {
- vm.invoke(() -> {
- IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
-
- spy.beforeWriteIndexRepository(doOnce(key -> moveBucket(destination, key)));
- });
- }
-
- protected void addCallbackToMovePrimaryOnQuery(VM vm, final DistributedMember destination) {
- vm.invoke(() -> {
- LuceneIndexFactorySpy factorySpy = LuceneIndexFactorySpy.injectSpy();
-
- factorySpy.setGetRespositoryConsumer(doOnce(key -> moveBucket(destination, key)));
- });
- }
-
- private void moveBucket(final DistributedMember destination, final Object key) {
- Region<Object, Object> region = getCache().getRegion(REGION_NAME);
- DistributedMember source = getCache().getDistributedSystem().getDistributedMember();
- System.out.println("WHAT");
- PartitionRegionHelper.moveBucketByKey(region, source, destination, key);
- }
-
- private void removeCallback(VM vm) {
- vm.invoke(() -> {
- IndexRepositorySpy.remove();
- InitialImageOperation.resetAllGIITestHooks();
- LuceneIndexFactorySpy.remove();
- });
- }
-
- private void rebalanceRegion(VM vm) {
- // Do a rebalance
- vm.invoke(() -> {
- RebalanceOperation op = getCache().getResourceManager().createRebalanceFactory().start();
- RebalanceResults results = op.getResults();
- });
- }
-
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerFixedPRDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerFixedPRDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerFixedPRDUnitTest.java
deleted file mode 100644
index 2622063..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerFixedPRDUnitTest.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
-
-import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.junit.categories.DistributedTest;
-import org.junit.experimental.categories.Category;
-
-@Category(DistributedTest.class)
-public class LuceneQueriesPeerFixedPRDUnitTest extends LuceneQueriesPeerPRRedundancyDUnitTest {
-
- @Override
- protected void initAccessor(SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache();
- LuceneTestUtilities.createFixedPartitionedRegion(getCache(), REGION_NAME, null, 0);
- }
-
- @Override
- protected void initDataStore(SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- LuceneTestUtilities.initDataStoreForFixedPR(getCache());
- }
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRDUnitTest.java
deleted file mode 100644
index f65777f..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRDUnitTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
-
-import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.junit.categories.DistributedTest;
-
-import org.junit.experimental.categories.Category;
-
-@Category(DistributedTest.class)
-public class LuceneQueriesPeerPRDUnitTest extends LuceneQueriesPRBase {
-
- @Override
- protected void initDataStore(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION)
- .setPartitionAttributes(getPartitionAttributes(false)).create(REGION_NAME);
- }
-
- @Override
- protected void initAccessor(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION_PROXY)
- .setPartitionAttributes(getPartitionAttributes(true)).create(REGION_NAME);
- }
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPROverflowDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPROverflowDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPROverflowDUnitTest.java
deleted file mode 100644
index 86ce713..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPROverflowDUnitTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
-
-import org.apache.geode.cache.EvictionAction;
-import org.apache.geode.cache.EvictionAttributes;
-import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.junit.categories.DistributedTest;
-
-import org.junit.experimental.categories.Category;
-
-@Category(DistributedTest.class)
-public class LuceneQueriesPeerPROverflowDUnitTest extends LuceneQueriesPRBase {
-
- @Override
- protected void initDataStore(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- EvictionAttributes evicAttr =
- EvictionAttributes.createLRUEntryAttributes(1, EvictionAction.OVERFLOW_TO_DISK);
- getCache().createRegionFactory(RegionShortcut.PARTITION_OVERFLOW)
- .setPartitionAttributes(getPartitionAttributes(false)).setEvictionAttributes(evicAttr)
- .create(REGION_NAME);
- }
-
- @Override
- protected void initAccessor(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION_PROXY)
- .setPartitionAttributes(getPartitionAttributes(true)).create(REGION_NAME);
- }
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRPersistentDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRPersistentDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRPersistentDUnitTest.java
deleted file mode 100644
index 4e809ce..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRPersistentDUnitTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.REGION_NAME;
-
-import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.junit.categories.DistributedTest;
-
-import org.junit.experimental.categories.Category;
-
-@Category(DistributedTest.class)
-public class LuceneQueriesPeerPRPersistentDUnitTest extends LuceneQueriesPRBase {
-
- @Override
- protected void initDataStore(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION_PERSISTENT)
- .setPartitionAttributes(getPartitionAttributes(false)).create(REGION_NAME);
- }
-
- @Override
- protected void initAccessor(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- getCache().createRegionFactory(RegionShortcut.PARTITION_PROXY)
- .setPartitionAttributes(getPartitionAttributes(true)).create(REGION_NAME);
- }
-}
http://git-wip-us.apache.org/repos/asf/geode/blob/a63b8302/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRRedundancyDUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRRedundancyDUnitTest.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRRedundancyDUnitTest.java
deleted file mode 100644
index 1b4303a..0000000
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneQueriesPeerPRRedundancyDUnitTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * 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.
- */
-package org.apache.geode.cache.lucene;
-
-import static org.apache.geode.cache.lucene.test.IndexRepositorySpy.*;
-import static org.apache.geode.cache.lucene.test.LuceneTestUtilities.*;
-import static org.junit.Assert.*;
-
-import java.util.concurrent.TimeUnit;
-
-import org.apache.geode.cache.CacheClosedException;
-import org.apache.geode.cache.Region;
-import org.apache.geode.cache.RegionShortcut;
-import org.apache.geode.cache.lucene.test.IndexRegionSpy;
-import org.apache.geode.cache.lucene.test.IndexRepositorySpy;
-import org.apache.geode.cache.lucene.test.LuceneTestUtilities;
-import org.apache.geode.distributed.DistributedMember;
-import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
-import org.apache.geode.internal.cache.InitialImageOperation;
-import org.apache.geode.internal.cache.InitialImageOperation.GIITestHook;
-import org.apache.geode.internal.cache.InitialImageOperation.GIITestHookType;
-import org.apache.geode.internal.cache.PartitionedRegion;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage;
-import org.apache.geode.internal.cache.partitioned.BecomePrimaryBucketMessage.BecomePrimaryBucketResponse;
-import org.apache.geode.test.dunit.SerializableRunnableIF;
-import org.apache.geode.test.dunit.VM;
-import org.apache.geode.test.junit.categories.DistributedTest;
-
-import org.awaitility.Awaitility;
-
-import org.junit.Test;
-import org.junit.experimental.categories.Category;
-
-@Category(DistributedTest.class)
-public class LuceneQueriesPeerPRRedundancyDUnitTest extends LuceneQueriesPRBase {
-
- @Override
- protected void initDataStore(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- Region region = getCache().createRegionFactory(RegionShortcut.PARTITION_REDUNDANT)
- .setPartitionAttributes(getPartitionAttributes(false)).create(REGION_NAME);
- }
-
- @Override
- protected void initAccessor(final SerializableRunnableIF createIndex) throws Exception {
- createIndex.run();
- Region region = getCache().createRegionFactory(RegionShortcut.PARTITION_PROXY_REDUNDANT)
- .setPartitionAttributes(getPartitionAttributes(true)).create(REGION_NAME);
- }
-
- @Test
- public void returnCorrectResultsWhenMovePrimaryHappensOnIndexUpdate()
- throws InterruptedException {
- final DistributedMember member2 =
- dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- addCallbackToMovePrimary(dataStore1, member2);
-
- putEntriesAndValidateResultsWithRedundancy();
- }
-
- @Test
- public void returnCorrectResultsWhenCloseCacheHappensOnIndexUpdate() throws InterruptedException {
- dataStore1.invoke(() -> {
- IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
-
- spy.beforeWriteIndexRepository(doAfterN(key -> getCache().close(), 2));
- });
-
- final String expectedExceptions = CacheClosedException.class.getName();
- dataStore1.invoke(addExceptionTag1(expectedExceptions));
-
- putEntriesAndValidateResultsWithRedundancy();
-
- // Wait until the cache is closed in datastore1
- dataStore1.invoke(
- () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
- }
-
- @Test
- public void returnCorrectResultsWhenCloseCacheHappensOnPartialIndexWrite()
- throws InterruptedException {
- final DistributedMember member2 =
- dataStore2.invoke(() -> getCache().getDistributedSystem().getDistributedMember());
- dataStore1.invoke(() -> {
- IndexRegionSpy.beforeWrite(getCache(), doAfterN(key -> getCache().close(), 100));
- });
-
- putEntriesAndValidateResultsWithRedundancy();
-
- // Wait until the cache is closed in datastore1
- dataStore1.invoke(
- () -> Awaitility.await().atMost(60, TimeUnit.SECONDS).until(basicGetCache()::isClosed));
- }
-
- @Test
- public void returnCorrectResultsWhenIndexUpdateHappensIntheMiddleofGII()
- throws InterruptedException {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- putEntryInEachBucket();
-
- dataStore2.invoke(() -> {
- InitialImageOperation.setGIITestHook(
- new GIITestHook(GIITestHookType.AfterSentRequestImage, "Do puts during request") {
- @Override
- public void reset() {
-
- }
-
- @Override
- public String getRegionName() {
- return "_B__index#__region.files_0";
- }
-
- @Override
- public void run() {
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- waitForFlushBeforeExecuteTextSearch(dataStore1, 30000);
- }
- });
- });
-
- dataStore2.invoke(() -> initDataStore(createIndex));
-
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore1, 30000));
- executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
- }
-
- private void putEntriesAndValidateResultsWithRedundancy() {
- SerializableRunnableIF createIndex = () -> {
- LuceneService luceneService = LuceneServiceProvider.get(getCache());
- luceneService.createIndex(INDEX_NAME, REGION_NAME, "text");
- };
- dataStore1.invoke(() -> initDataStore(createIndex));
- dataStore2.invoke(() -> initDataStore(createIndex));
- accessor.invoke(() -> initAccessor(createIndex));
- dataStore1.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- dataStore2.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
- accessor.invoke(() -> LuceneTestUtilities.pauseSender(getCache()));
-
- putEntryInEachBucket();
-
- dataStore1.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- dataStore2.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
- accessor.invoke(() -> LuceneTestUtilities.resumeSender(getCache()));
-
- assertTrue(waitForFlushBeforeExecuteTextSearch(dataStore2, 60000));
-
- executeTextSearch(accessor, "world", "text", NUM_BUCKETS);
- }
-
- protected void addCallbackToMovePrimary(VM vm, final DistributedMember destination) {
- vm.invoke(() -> {
- IndexRepositorySpy spy = IndexRepositorySpy.injectSpy();
-
- spy.beforeWriteIndexRepository(doOnce(key -> moveBucket(destination, key)));
- });
- }
-
- private void moveBucket(final DistributedMember destination, final Object key) {
- PartitionedRegion region = (PartitionedRegion) getCache().getRegion(REGION_NAME);
-
- BecomePrimaryBucketResponse response =
- BecomePrimaryBucketMessage.send((InternalDistributedMember) destination, region,
- region.getKeyInfo(key).getBucketId(), true);
- assertNotNull(response);
- assertTrue(response.waitForResponse());
- }
-}