From 6b81dfe86dd30fe7a6ce3197b6f6419b499df5e3 Mon Sep 17 00:00:00 2001 From: Pedro Ruivo Date: Mon, 7 Oct 2013 13:06:02 +0100 Subject: [PATCH] ISPN-3593 Disallow storing a Lucene index when storeAsBinary is enabled --- .../lucene/impl/DirectoryBuilderImpl.java | 20 ++++-- .../org/infinispan/lucene/logging/Log.java | 2 + .../NotStoreAsBinaryValidationTest.java | 66 +++++++++++++++++++ 3 files changed, 82 insertions(+), 6 deletions(-) create mode 100644 lucene/lucene-v3/src/test/java/org/infinispan/lucene/configuration/NotStoreAsBinaryValidationTest.java diff --git a/lucene/lucene-v3/src/main/java/org/infinispan/lucene/impl/DirectoryBuilderImpl.java b/lucene/lucene-v3/src/main/java/org/infinispan/lucene/impl/DirectoryBuilderImpl.java index 02e45f0050cb..e70456d1dd73 100644 --- a/lucene/lucene-v3/src/main/java/org/infinispan/lucene/impl/DirectoryBuilderImpl.java +++ b/lucene/lucene-v3/src/main/java/org/infinispan/lucene/impl/DirectoryBuilderImpl.java @@ -3,6 +3,7 @@ import org.apache.lucene.store.Directory; import org.apache.lucene.store.LockFactory; import org.infinispan.Cache; +import org.infinispan.configuration.cache.Configuration; import org.infinispan.lucene.directory.BuildContext; import org.infinispan.lucene.locking.BaseLockFactory; import org.infinispan.lucene.logging.Log; @@ -38,9 +39,9 @@ public class DirectoryBuilderImpl implements BuildContext { private LockFactory lockFactory = null; public DirectoryBuilderImpl(Cache metadataCache, Cache chunksCache, Cache distLocksCache, String indexName) { - this.metadataCache = checkNoExpiryConfigured(checkNotNull(metadataCache, "metadataCache"), indexName); - this.chunksCache = checkNoExpiryConfigured(checkNotNull(chunksCache, "chunksCache"), indexName); - this.distLocksCache = checkNoExpiryConfigured(checkNotNull(distLocksCache, "distLocksCache"), indexName); + this.metadataCache = checkValidConfiguration(checkNotNull(metadataCache, "metadataCache"), indexName); + this.chunksCache = checkValidConfiguration(checkNotNull(chunksCache, "chunksCache"), indexName); + this.distLocksCache = checkValidConfiguration(checkNotNull(distLocksCache, "distLocksCache"), indexName); this.indexName = checkNotNull(indexName, "indexName"); } @@ -104,13 +105,20 @@ private static T checkNotNull(final T v,final String objectname) { return v; } - private static Cache checkNoExpiryConfigured(final Cache cache, String indexName) { - if ( cache != null && cache.getCacheConfiguration().expiration().maxIdle() != -1) { + private static Cache checkValidConfiguration(final Cache cache, String indexName) { + if (cache == null) { + return null; + } + Configuration configuration = cache.getCacheConfiguration(); + if (configuration.expiration().maxIdle() != -1) { throw log.luceneStorageHavingIdleTimeSet( indexName, cache.getName() ); } - if ( cache != null && cache.getCacheConfiguration().expiration().lifespan() != -1) { + if (configuration.expiration().lifespan() != -1) { throw log.luceneStorageHavingLifespanSet( indexName, cache.getName() ); } + if (configuration.storeAsBinary().enabled()) { + throw log.luceneStorageAsBinaryEnabled(indexName, cache.getName()); + } return cache; } diff --git a/lucene/lucene-v3/src/main/java/org/infinispan/lucene/logging/Log.java b/lucene/lucene-v3/src/main/java/org/infinispan/lucene/logging/Log.java index c023c4b06f7f..6a3c317ca6c5 100644 --- a/lucene/lucene-v3/src/main/java/org/infinispan/lucene/logging/Log.java +++ b/lucene/lucene-v3/src/main/java/org/infinispan/lucene/logging/Log.java @@ -78,4 +78,6 @@ public interface Log extends org.infinispan.util.logging.Log { @Message(value = "'%s' must not be null", id = 15016) IllegalArgumentException requiredParameterWasPassedNull(String objectname); + @Message(value = "Lucene Directory for index '%s' can not use Cache '%s': store as binary enabled on the Cache configuration!", id = 15017) + IllegalArgumentException luceneStorageAsBinaryEnabled(String indexName, String cacheName); } diff --git a/lucene/lucene-v3/src/test/java/org/infinispan/lucene/configuration/NotStoreAsBinaryValidationTest.java b/lucene/lucene-v3/src/test/java/org/infinispan/lucene/configuration/NotStoreAsBinaryValidationTest.java new file mode 100644 index 000000000000..cb76337a5b75 --- /dev/null +++ b/lucene/lucene-v3/src/test/java/org/infinispan/lucene/configuration/NotStoreAsBinaryValidationTest.java @@ -0,0 +1,66 @@ +package org.infinispan.lucene.configuration; + +import org.infinispan.Cache; +import org.infinispan.configuration.cache.ConfigurationBuilder; +import org.infinispan.lucene.CacheTestSupport; +import org.infinispan.lucene.directory.DirectoryBuilder; +import org.infinispan.manager.EmbeddedCacheManager; +import org.infinispan.test.AbstractInfinispanTest; +import org.infinispan.test.TestingUtil; +import org.infinispan.test.fwk.TestCacheManagerFactory; +import org.testng.annotations.Test; + +/** + * Verifies that the Lucene Directory correctly refuses to use a Cache with store as binary enabled. + * + * @author Pedro Ruivo + * @since 6.0 + */ +@Test(groups = "functional", testName = "lucene.configuration.NotStoreAsBinaryValidationTest") +public class NotStoreAsBinaryValidationTest extends AbstractInfinispanTest { + + private static final String INDEX_NAME = "test-index"; + private static final String CACHE_NAME = "test-cache"; + private static final String ERROR_MESSAGE_EXP = "ISPN(\\d)*: Lucene Directory for index '" + INDEX_NAME + + "' can not use Cache '" + CACHE_NAME + "': store as binary enabled on the Cache configuration!"; + + @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ERROR_MESSAGE_EXP) + public void failOnStoreKeysAsBinary() { + ConfigurationBuilder builder = new ConfigurationBuilder(); + builder.storeAsBinary().enable().storeKeysAsBinary(true); + failIfStoreAsBinaryEnabled(builder); + } + + @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ERROR_MESSAGE_EXP) + public void failOnStoreValuesAsBinary() { + ConfigurationBuilder builder = new ConfigurationBuilder(); + builder.storeAsBinary().enable().storeValuesAsBinary(true); + failIfStoreAsBinaryEnabled(builder); + } + + @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ERROR_MESSAGE_EXP) + public void failOnStoreKeysAndValuesAsBinary() { + ConfigurationBuilder builder = new ConfigurationBuilder(); + builder.storeAsBinary().enable() + .storeValuesAsBinary(true) + .storeKeysAsBinary(true); + failIfStoreAsBinaryEnabled(builder); + } + + private void failIfStoreAsBinaryEnabled(ConfigurationBuilder configuration) { + EmbeddedCacheManager cacheManager = null; + try { + ConfigurationBuilder cfg = CacheTestSupport.createLocalCacheConfiguration(); + cfg.storeAsBinary().enable(); + cacheManager = TestCacheManagerFactory.createCacheManager(configuration); + Cache cache = cacheManager.getCache(CACHE_NAME); + + DirectoryBuilder.newDirectoryInstance(cache, cache, cache, INDEX_NAME).create(); + } finally { + if (cacheManager != null) { + TestingUtil.killCacheManagers(cacheManager); + } + } + } + +}