[ https://issues.apache.org/jira/browse/GEODE-4089?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16291736#comment-16291736 ]
Shelley Lynn Hughes-Godfrey commented on GEODE-4089: ---------------------------------------------------- To fix this issue in geode 1.2 and 1.3 ... cherry-pick this commit from 1.4 and modify one line to match the correct parameters: ``` commit 01dc11fc51bdaacefccf66f7d7d449a40a6e6a45 Author: Lynn Hughes-Godfrey <lhughesgodf...@pivotal.io> Date: Fri Nov 3 14:59:55 2017 -0700 GEODE-3953: Incorrect use of .equals() for comparison of fieldname arrays GEODE-3954: Misleading Exception message with mismatched fieldAnalyzers - corrected equals comparisons of fieldname arrays - corrected Exception message for mismatched fieldAnalyzers to refer to field analyzers (vs. fieldnames) when remote and local fieldAnalyzers are different sizes - corrected Exception message to display fieldAnalyzers vs. fieldnames when remote and local fieldAnalyzer maps are different sizes ``` Adjust the parameters for this (by removing extra null at end): ``` + private LuceneIndexCreationProfile getReverseFieldsLuceneIndexCreationProfile() { + return new LuceneIndexCreationProfile(INDEX_NAME, REGION_NAME, + new String[] {"field2", "field1"}, new StandardAnalyzer(), null); + } + ``` One could also add a new test in the newer version of geode to verify this: ``` diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneSearchWithRollingUpgradeDUnit.java b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneSearchWithRollingUpgradeDUnit.java index b622adf..238631c 100644 --- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneSearchWithRollingUpgradeDUnit.java +++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/LuceneSearchWithRollingUpgradeDUnit.java @@ -19,10 +19,12 @@ import static org.junit.Assert.assertEquals; import java.io.File; import java.io.IOException; +import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Method; import java.net.InetAddress; import java.net.UnknownHostException; +import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.Properties; @@ -138,6 +140,12 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa executeLuceneQueryWithServerRollOvers("persistentPartitioned", oldVersion); } + @Test + public void luceneQueryReturnsCorrectResultsAfterServersRollOverWithMultipleIndexedFields() + throws Exception { + executeLuceneQueryWithMultipleIndexedFields("partitionedRedundant", oldVersion); + } + // 2 locator, 2 servers @Test public void luceneQueryReturnsCorrectResultAfterTwoLocatorsWithTwoServersAreRolled() @@ -574,6 +582,108 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa } } + // We start an "old" locator and old servers + // We roll the locator + // Now we roll all the servers from old to new + public void executeLuceneQueryWithMultipleIndexedFields(String regionType, String startingVersion) + throws Exception { + final Host host = Host.getHost(0); + VM server1 = host.getVM(startingVersion, 0); + VM server2 = host.getVM(startingVersion, 1); + VM server3 = host.getVM(startingVersion, 2); + VM locator = host.getVM(startingVersion, 3); + + + String regionName = "aRegion"; + String shortcutName = null; + if ((regionType.equals("partitionedRedundant"))) { + shortcutName = RegionShortcut.PARTITION_REDUNDANT.name(); + } else if ((regionType.equals("persistentPartitioned"))) { + shortcutName = RegionShortcut.PARTITION_PERSISTENT.name(); + for (int i = 0; i < testingDirs.length; i++) { + testingDirs[i] = new File(diskDir, "diskStoreVM_" + String.valueOf(host.getVM(i).getId())) + .getAbsoluteFile(); + if (!testingDirs[i].exists()) { + System.out.println(" Creating diskdir for server: " + i); + testingDirs[i].mkdirs(); + } + } + } + + int[] locatorPorts = AvailablePortHelper.getRandomAvailableTCPPorts(1); + String hostName = NetworkUtils.getServerHostName(host); + String locatorString = getLocatorString(locatorPorts); + final Properties locatorProps = new Properties(); + // configure all class loaders for each vm + + try { + locator.invoke(invokeStartLocator(hostName, locatorPorts[0], getTestMethodName(), + locatorString, locatorProps)); + invokeRunnableInVMs(invokeCreateCache(getSystemProperties(locatorPorts)), server1, server2, + server3); + + // Create Lucene Indexes + final String[] fieldNames = {"status", "type"}; + server1.invoke(() -> createLuceneIndex(cache, regionName, INDEX_NAME, fieldNames)); + server2.invoke(() -> createLuceneIndex(cache, regionName, INDEX_NAME, fieldNames)); + server3.invoke(() -> createLuceneIndex(cache, regionName, INDEX_NAME, fieldNames)); + + // create region + if ((regionType.equals("persistentPartitioned"))) { + for (int i = 0; i < testingDirs.length; i++) { + CacheSerializableRunnable runnable = + invokeCreatePersistentPartitionedRegion(regionName, testingDirs[i]); + invokeRunnableInVMs(runnable, host.getVM(i)); + } + } else { + invokeRunnableInVMs(invokeCreateRegion(regionName, shortcutName), server1, server2, + server3); + } + int expectedRegionSize = 10; + putSerializableObjectAndVerifyLuceneQueryResult(server1, regionName, expectedRegionSize, 0, + 10, server2, server3); + locator = rollLocatorToCurrent(locator, hostName, locatorPorts[0], getTestMethodName(), + locatorString); + + String[] reversedFieldNames = {"type", "status"}; + server1 = rollServerToCurrentAndCreateRegion(server1, regionType, testingDirs[0], + shortcutName, regionName, reversedFieldNames, locatorPorts); + verifyLuceneQueryResultInEachVM(regionName, expectedRegionSize, server1); + expectedRegionSize += 5; + putSerializableObjectAndVerifyLuceneQueryResult(server1, regionName, expectedRegionSize, 5, + 15, server2, server3); + expectedRegionSize += 5; + putSerializableObjectAndVerifyLuceneQueryResult(server2, regionName, expectedRegionSize, 10, + 20, server1, server3); + + server2 = rollServerToCurrentAndCreateRegion(server2, regionType, testingDirs[1], + shortcutName, regionName, fieldNames, locatorPorts); + verifyLuceneQueryResultInEachVM(regionName, expectedRegionSize, server2); + expectedRegionSize += 5; + putSerializableObjectAndVerifyLuceneQueryResult(server2, regionName, expectedRegionSize, 15, + 25, server1, server3); + expectedRegionSize += 5; + putSerializableObjectAndVerifyLuceneQueryResult(server3, regionName, expectedRegionSize, 20, + 30, server2, server3); + + server3 = rollServerToCurrentAndCreateRegion(server3, regionType, testingDirs[2], + shortcutName, regionName, fieldNames, locatorPorts); + verifyLuceneQueryResultInEachVM(regionName, expectedRegionSize, server3); + putSerializableObjectAndVerifyLuceneQueryResult(server3, regionName, expectedRegionSize, 15, + 25, server1, server2); + putSerializableObjectAndVerifyLuceneQueryResult(server1, regionName, expectedRegionSize, 20, + 30, server1, server2, server3); + + + } finally { + invokeRunnableInVMs(true, invokeStopLocator(), locator); + invokeRunnableInVMs(true, invokeCloseCache(), server1, server2, server3); + if ((regionType.equals("persistentPartitioned"))) { + deleteDiskStores(); + } + } + } + private void putSerializableObjectAndVerifyLuceneQueryResult(VM putter, String regionName, int expectedRegionSize, int start, int end, VM... vms) throws Exception { // do puts @@ -617,7 +727,7 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa Object luceneService = getLuceneService.invoke(luceneServiceProvider, cache); luceneService.getClass() .getMethod("waitUntilFlushed", String.class, String.class, long.class, TimeUnit.class) - .invoke(luceneService, INDEX_NAME, regionName, 60, TimeUnit.SECONDS); + .invoke(luceneService, INDEX_NAME, regionName, 120, TimeUnit.SECONDS); Method createLuceneQueryFactoryMethod = luceneService.getClass().getMethod("createLuceneQueryFactory"); createLuceneQueryFactoryMethod.setAccessible(true); @@ -687,8 +797,16 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa private VM rollServerToCurrentAndCreateRegion(VM oldServer, String regionType, File diskdir, String shortcutName, String regionName, int[] locatorPorts) throws Exception { + final String[] fieldNames = {"status"}; + return rollServerToCurrentAndCreateRegion(oldServer, regionType, diskdir, shortcutName, + regionName, fieldNames, locatorPorts); + } + + private VM rollServerToCurrentAndCreateRegion(VM oldServer, String regionType, File diskdir, + String shortcutName, String regionName, String[] fieldNames, int[] locatorPorts) + throws Exception { VM rollServer = rollServerToCurrent(oldServer, locatorPorts); - rollServer.invoke(() -> createLuceneIndex(cache, regionName, INDEX_NAME)); + rollServer.invoke(() -> createLuceneIndex(cache, regionName, INDEX_NAME, fieldNames)); // recreate region on "rolled" server if ((regionType.equals("persistentPartitioned"))) { CacheSerializableRunnable runnable = @@ -958,6 +1076,12 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa public static void createLuceneIndex(Object cache, String regionName, String indexName) throws Exception { + final String[] fieldNames = {"status"}; + createLuceneIndex(cache, regionName, indexName, fieldNames); + } + + public static void createLuceneIndex(Object cache, String regionName, String indexName, + String[] fieldNames) throws Exception { Class luceneServiceProvider = Thread.currentThread().getContextClassLoader() .loadClass("org.apache.geode.cache.lucene.LuceneServiceProvider"); Method getLuceneService = luceneServiceProvider.getMethod("get", GemFireCache.class); @@ -966,8 +1090,8 @@ public class LuceneSearchWithRollingUpgradeDUnit extends JUnit4DistributedTestCa luceneService.getClass().getMethod("createIndexFactory"); createLuceneIndexFactoryMethod.setAccessible(true); Object luceneIndexFactory = createLuceneIndexFactoryMethod.invoke(luceneService); - luceneIndexFactory.getClass().getMethod("addField", String.class).invoke(luceneIndexFactory, - "status"); + luceneIndexFactory.getClass().getMethod("setFields", String[].class).invoke(luceneIndexFactory, + (Object) fieldNames); luceneIndexFactory.getClass().getMethod("create", String.class, String.class) .invoke(luceneIndexFactory, indexName, regionName); } ``` > Lucene create index can fail due to comparison of indexedFields as an array > (if order of indexes is different) > -------------------------------------------------------------------------------------------------------------- > > Key: GEODE-4089 > URL: https://issues.apache.org/jira/browse/GEODE-4089 > Project: Geode > Issue Type: Bug > Components: lucene > Affects Versions: 1.4.0 > Reporter: Shelley Lynn Hughes-Godfrey > Assignee: Shelley Lynn Hughes-Godfrey > > This issue was fixed in geode 1.4 (GEODE-3953: Incorrect use of .equals() for > comparison of fieldname arrays), but given that this issue exists in earlier > versions, re-initialization of members creating lucene indexes can fail when > upgrading from 1.2 and 1.3 to 1.4 when there is a mix of old and new version > members in the Distributed System. > {noformat} > Cannot create Lucene index index on region /region with fields [field2, > field1] because another member defines the same index with fields [field1, > field2]. > at org.junit.Assert.fail(Assert.java:88) > at org.junit.Assert.failNotEquals(Assert.java:834) > at org.junit.Assert.assertEquals(Assert.java:118) > at org.junit.Assert.assertEquals(Assert.java:144) > at > org.apache.geode.cache.lucene.internal.LuceneIndexCreationProfileJUnitTest.testCheckCompatibility(LuceneIndexCreationProfileJUnitTest.java:64) > at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) > at > sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) > at > sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) > at java.lang.reflect.Method.invoke(Method.java:497) > at > org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50) > at > org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12) > at > org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47) > at > junitparams.internal.InvokeParameterisedMethod.evaluate(InvokeParameterisedMethod.java:234) > at > junitparams.internal.ParameterisedTestMethodRunner.runMethodInvoker(ParameterisedTestMethodRunner.java:47) > at > junitparams.internal.ParameterisedTestMethodRunner.runTestMethod(ParameterisedTestMethodRunner.java:40) > at > junitparams.internal.ParameterisedTestClassRunner.runParameterisedTest(ParameterisedTestClassRunner.java:146) > at junitparams.JUnitParamsRunner.runChild(JUnitParamsRunner.java:417) > at junitparams.JUnitParamsRunner.runChild(JUnitParamsRunner.java:386) > at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290) > at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71) > at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288) > at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58) > at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268) > at org.junit.runners.ParentRunner.run(ParentRunner.java:363) > at org.junit.runner.JUnitCore.run(JUnitCore.java:137) > at > com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68) > at > com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:51) > at > com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242) > at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70) > {noformat} -- This message was sent by Atlassian JIRA (v6.4.14#64029)