Merge pull request #3 from mmolimar/configurable_cache_size

Removing configurable cache size by env variable

Author: huggsboson

src/main/java/com/github/fge/jsonschema/core/load/SchemaLoader.java

@@ -32,7 +32,6 @@
 import com.github.fge.msgsimple.bundle.MessageBundle;
 import com.github.fge.msgsimple.load.MessageBundles;
 import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheBuilderSpec;
 import com.google.common.cache.CacheLoader;
 import com.google.common.cache.LoadingCache;
 import com.google.common.collect.ImmutableMap;
@@ -101,9 +100,11 @@ public SchemaLoader(final LoadingConfiguration cfg)
         manager = new URIManager(cfg);
         preloadedSchemas = ImmutableMap.copyOf(cfg.getPreloadedSchemas());
 
-        cache = CacheBuilder.newBuilder()
-            .maximumSize(cfg.getEnableCache() ? cfg.getCacheSize() : 0) // cache size zero disables caching
-            .build(new CacheLoader<URI, JsonNode>()
+        CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
+        if (cfg.getCacheSize() != -1) {
+        	builder.maximumSize(cfg.getCacheSize());
+        }
+        cache = builder.build(new CacheLoader<URI, JsonNode>()
             {
                 @Nonnull
                 @Override

src/main/java/com/github/fge/jsonschema/core/load/configuration/LoadingConfiguration.java

@@ -89,19 +89,11 @@ public final class LoadingConfiguration
     final URITranslatorConfiguration translatorCfg;
 
     /**
-     * Should we cache schemas
+     * Cache size
      *
      * <p>Note that this do not affect preloaded schemas; these are always
      * cached.</p>
      */
-    final boolean enableCache;
-
-    /**
-     * Cache size
-     *
-     * if enableCache is false, this field is ignored.
-     * enableCache = true && cacheSize = 0 == enableCache = false
-     */
     final int cacheSize;
 
     /**
@@ -173,7 +165,6 @@ public static LoadingConfiguration byDefault()
         preloadedSchemas = ImmutableMap.copyOf(builder.preloadedSchemas);
         parserFeatures = EnumSet.copyOf(builder.parserFeatures);
         reader = buildReader();
-        enableCache = builder.enableCache;
         cacheSize = builder.cacheSize;
     }
 
@@ -246,17 +237,20 @@ public JsonNodeReader getReader()
      * Return if we want to cache loaded schema or not
      * note that this do not affect preloadedSchema that are always cached
      * 
+     * @deprecated Use cacheSize getter instead to get the cache size
+     * 
      * @return if the cache has to be enabled
      */
+    @Deprecated
     public boolean getEnableCache() {
-        return enableCache;
+        return this.cacheSize != 0;
     }
-
+    
     /**
      * Return the size of the cache to use
      * note that this do not affect preloadedSchema that are always cached
      *
-     * @return the size of the cache, if enabled
+     * @return the size of the cache. A zero-value means that it is not enabled
      */
     public int getCacheSize() {
         return cacheSize;

src/main/java/com/github/fge/jsonschema/core/load/configuration/LoadingConfigurationBuilder.java

@@ -57,6 +57,8 @@ public final class LoadingConfigurationBuilder
      * EnumSets to collect them, so we have to do that...
      */
     private static final EnumSet<JsonParser.Feature> DEFAULT_PARSER_FEATURES;
+    
+    private static final int DEFAULT_CACHE_SIZE = 512;
 
     static {
         DEFAULT_PARSER_FEATURES = EnumSet.noneOf(JsonParser.Feature.class);
@@ -78,14 +80,9 @@ public final class LoadingConfigurationBuilder
     URITranslatorConfiguration translatorCfg;
 
     /**
-     * Loaded schemas are cached by default
-     */
-    boolean enableCache = true;
-
-    /**
-     * Cache size is 4096 by default
+     * Cache size is 512 by default
      */
-    int cacheSize = 4096;
+    int cacheSize = DEFAULT_CACHE_SIZE;
 
     /**
      * Dereferencing mode
@@ -137,28 +134,31 @@ public final class LoadingConfigurationBuilder
         dereferencing = cfg.dereferencing;
         preloadedSchemas = Maps.newHashMap(cfg.preloadedSchemas);
         parserFeatures = EnumSet.copyOf(cfg.parserFeatures);
-        enableCache = cfg.enableCache;
         cacheSize = cfg.cacheSize;
     }
-
+    
     /**
      * Should we enable caching of downloaded schemas
+     * 
+     * @deprecated Just for backward compatibility
+     *     Use cacheSize setter instead to set the maximum size of the cache
      *
      * <p>Note that this does <b>not</b> affect preloaded schemas</p>
      * 
      * @param enableCache if loaded schemas have to be cached
      * @return this
      */
+    @Deprecated
     public LoadingConfigurationBuilder setEnableCache(final boolean enableCache)
     {
-        this.enableCache = enableCache;
+    	this.cacheSize = enableCache ? DEFAULT_CACHE_SIZE : 0;
         return this;
     }
 
     /**
      * How many schemas should be cached
-     * <p>Note if enableCache is false this setting is ignored</p>
-     * <p>Note setting enableCache to false or this to zero both effectively disable the cache</p>
+     * <p>Note setting to zero effectively disables the cache</p>
+     * <p>Note settting to -1 creates an unlimited cache</p>
      * <p>Note that this does <b>not</b> affect preloaded schemas</p>
      *
      * @param cacheSize if loaded schemas have to be cached

src/main/java/com/github/fge/jsonschema/core/processing/CachingProcessor.java

@@ -53,8 +53,7 @@ public final class CachingProcessor<IN extends MessageProvider, OUT extends Mess
     private static final MessageBundle BUNDLE
         = MessageBundles.getBundle(JsonSchemaCoreMessageBundle.class);
 
-    public static final String CACHE_SIZE_PROPERTY_NAME = "com.github.fge.jsonschema.processorCacheSize";
-    public static final int DEFAULT_CACHE_SIZE = 4096;
+    private static final int DEFAULT_CACHE_SIZE = 512;
 
     /**
      * The wrapped processor
@@ -89,7 +88,7 @@ public CachingProcessor(final Processor<IN, OUT> processor)
     public CachingProcessor(final Processor<IN, OUT> processor,
         final Equivalence<IN> equivalence)
     {
-        this(processor, equivalence, Integer.getInteger(CACHE_SIZE_PROPERTY_NAME, DEFAULT_CACHE_SIZE));
+        this(processor, equivalence, DEFAULT_CACHE_SIZE);
     }
     /**
      * Main constructor
@@ -104,11 +103,14 @@ public CachingProcessor(final Processor<IN, OUT> processor,
     {
         BUNDLE.checkNotNull(processor, "processing.nullProcessor");
         BUNDLE.checkNotNull(equivalence, "processing.nullEquivalence");
+        BUNDLE.checkArgument(cacheSize >= -1, "processing.invalidCacheSize");
         this.processor = processor;
         this.equivalence = equivalence;
-        cache = CacheBuilder.newBuilder()
-                .maximumSize(cacheSize)
-                .build(loader());
+        CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
+        if (cacheSize != -1) {
+        	builder.maximumSize(cacheSize);
+        }
+        cache = builder.build(loader());
     }
 
     @Override

src/main/resources/com/github/fge/jsonschema/core/core.properties

@@ -48,6 +48,7 @@ processing.nullLevel = log level must not be null
 processing.nullPredicate = predicate cannot be null
 processing.nullProcessor = processor cannot be null
 processing.nullReport = report cannot be null
+processing.invalidCacheSize = cache size must be greater than -1. -1 value sets a cache with unlimited records, zero-value disables the cache
 refProcessing.danglingRef = JSON Reference "%s" cannot be resolved
 refProcessing.refLoop = JSON Reference "%s" loops on itself
 refProcessing.unhandledScheme = URI scheme "%s" not supported (URI: "%s")

src/test/java/com/github/fge/jsonschema/core/load/SchemaLoaderTest.java

@@ -141,7 +141,7 @@ public void preloadedSchemasAreNotFetchedAgain()
         verify(mock, never()).fetch(uri);
 
         //even if cache is disabled
-        cfg = builder.setEnableCache(false).freeze();
+        cfg = builder.setCacheSize(0).freeze();
         registry = new SchemaLoader(cfg);
         registry.get(uri);
         verify(mock, never()).fetch(uri);        
@@ -184,7 +184,7 @@ public InputStream fetch(final URI source)
 
         final LoadingConfiguration cfg = LoadingConfiguration.newBuilder()
             .addScheme("foo", downloader)
-            .setEnableCache(false)
+            .setCacheSize(0)
             .freeze();
         final SchemaLoader loader = new SchemaLoader(cfg);
 
@@ -210,7 +210,6 @@ public InputStream fetch(final URI source)
 
         final LoadingConfiguration cfg = LoadingConfiguration.newBuilder()
             .addScheme("foo", downloader)
-            .setEnableCache(true)
             .setCacheSize(0)
             .freeze();
         final SchemaLoader loader = new SchemaLoader(cfg);

src/test/java/com/github/fge/jsonschema/core/processing/CachingProcessorTest.java

@@ -26,7 +26,6 @@
 import com.github.fge.jsonschema.core.util.equivalence.Equivalences;
 import com.github.fge.msgsimple.bundle.MessageBundle;
 import com.github.fge.msgsimple.load.MessageBundles;
-import com.google.common.cache.CacheBuilder;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
@@ -75,6 +74,18 @@ public void cannotInputNullEquivalence()
         }
     }
 
+    @Test
+    public void cannotInputInvalidCacheSize()
+    {
+        try {
+            new CachingProcessor<In, Out>(processor, Equivalences.<In>identity(), -2);
+            fail("No exception thrown!!");
+        } catch (IllegalArgumentException e) {
+            assertEquals(e.getMessage(),
+                BUNDLE.getMessage("processing.invalidCacheSize"));
+        }
+    }
+
     @Test
     public void cachedValueIsNotProcessedTwiceButReportedTwice()
         throws ProcessingException