You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by no...@apache.org on 2019/07/30 03:38:59 UTC

[lucene-solr] branch jira/SOLR-13659 updated: SOLR-13659: initial commit

This is an automated email from the ASF dual-hosted git repository.

noble pushed a commit to branch jira/SOLR-13659
in repository https://gitbox.apache.org/repos/asf/lucene-solr.git


The following commit(s) were added to refs/heads/jira/SOLR-13659 by this push:
     new 1c2392d  SOLR-13659: initial commit
1c2392d is described below

commit 1c2392ddbb98e961921272ba0c779bf0644840e1
Author: noble <no...@apache.org>
AuthorDate: Tue Jul 30 13:38:44 2019 +1000

    SOLR-13659: initial commit
---
 .../src/java/org/apache/solr/core/SolrConfig.java  |  37 +++--
 .../org/apache/solr/search/SolrCacheHolder.java    | 179 +++++++++++++++++++++
 .../apache/solr/search/SolrDocumentFetcher.java    |   7 +-
 .../org/apache/solr/search/SolrIndexSearcher.java  | 152 ++++++++---------
 .../src/test/org/apache/solr/core/TestConfig.java  |  18 +--
 5 files changed, 281 insertions(+), 112 deletions(-)

diff --git a/solr/core/src/java/org/apache/solr/core/SolrConfig.java b/solr/core/src/java/org/apache/solr/core/SolrConfig.java
index e212f50..a14786e 100644
--- a/solr/core/src/java/org/apache/solr/core/SolrConfig.java
+++ b/solr/core/src/java/org/apache/solr/core/SolrConfig.java
@@ -61,10 +61,9 @@ import org.apache.solr.response.QueryResponseWriter;
 import org.apache.solr.response.transform.TransformerFactory;
 import org.apache.solr.rest.RestManager;
 import org.apache.solr.schema.IndexSchemaFactory;
-import org.apache.solr.search.CacheConfig;
-import org.apache.solr.search.FastLRUCache;
 import org.apache.solr.search.QParserPlugin;
 import org.apache.solr.search.SolrCache;
+import org.apache.solr.search.SolrCacheHolder;
 import org.apache.solr.search.ValueSourceParser;
 import org.apache.solr.search.stats.StatsCache;
 import org.apache.solr.servlet.SolrRequestParsers;
@@ -260,19 +259,19 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
     
     useRangeVersionsForPeerSync = getBool("peerSync/useRangeVersions", true);
 
-    filterCacheConfig = CacheConfig.getConfig(this, "query/filterCache");
-    queryResultCacheConfig = CacheConfig.getConfig(this, "query/queryResultCache");
-    documentCacheConfig = CacheConfig.getConfig(this, "query/documentCache");
-    CacheConfig conf = CacheConfig.getConfig(this, "query/fieldValueCache");
+    filterCacheFactory = SolrCacheHolder.Factory.create(this, "query/filterCache");
+    queryResultCacheFactory = SolrCacheHolder.Factory.create(this, "query/queryResultCache");
+    documentCacheFactory = SolrCacheHolder.Factory.create(this, "query/documentCache");
+    SolrCacheHolder.Factory conf = SolrCacheHolder.Factory.create(this, "query/fieldValueCache");
     if (conf == null) {
       Map<String, String> args = new HashMap<>();
       args.put(NAME, "fieldValueCache");
       args.put("size", "10000");
       args.put("initialSize", "10");
       args.put("showItems", "-1");
-      conf = new CacheConfig(FastLRUCache.class, args, null);
+      conf = new SolrCacheHolder.Factory(args);
     }
-    fieldValueCacheConfig = conf;
+    fieldValueCacheFactory = conf;
     useColdSearcher = getBool("query/useColdSearcher", false);
     dataDir = get("dataDir", null);
     if (dataDir != null && dataDir.length() == 0) dataDir = null;
@@ -293,14 +292,14 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
     slowQueryThresholdMillis = getInt("query/slowQueryThresholdMillis", -1);
     for (SolrPluginInfo plugin : plugins) loadPluginInfo(plugin);
 
-    Map<String, CacheConfig> userCacheConfigs = CacheConfig.getMultipleConfigs(this, "query/cache");
+    Map<String, SolrCacheHolder.Factory> userCacheConfigs = SolrCacheHolder.Factory.create(this, "query/cache",true);
     List<PluginInfo> caches = getPluginInfos(SolrCache.class.getName());
     if (!caches.isEmpty()) {
       for (PluginInfo c : caches) {
-        userCacheConfigs.put(c.name, CacheConfig.getConfig(this, "cache", c.attributes, null));
+        userCacheConfigs.put(c.name, new SolrCacheHolder.Factory(c.attributes));
       }
     }
-    this.userCacheConfigs = Collections.unmodifiableMap(userCacheConfigs);
+    this.userCacheFactory = Collections.unmodifiableMap(userCacheConfigs);
 
     updateHandlerInfo = loadUpdatehandlerInfo();
 
@@ -547,11 +546,11 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
 //  public final int filtOptCacheSize;
 //  public final float filtOptThreshold;
   // SolrIndexSearcher - caches configurations
-  public final CacheConfig filterCacheConfig;
-  public final CacheConfig queryResultCacheConfig;
-  public final CacheConfig documentCacheConfig;
-  public final CacheConfig fieldValueCacheConfig;
-  public final Map<String, CacheConfig> userCacheConfigs;
+  public final SolrCacheHolder.Factory filterCacheFactory;
+  public final SolrCacheHolder.Factory queryResultCacheFactory;
+  public final SolrCacheHolder.Factory documentCacheFactory;
+  public final SolrCacheHolder.Factory fieldValueCacheFactory;
+  public final Map<String, SolrCacheHolder.Factory> userCacheFactory;
   // SolrIndexSearcher - more...
   public final boolean useFilterForSortedQuery;
   public final int queryResultWindowSize;
@@ -919,7 +918,7 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
     }
 
 
-    addCacheConfig(m, filterCacheConfig, queryResultCacheConfig, documentCacheConfig, fieldValueCacheConfig);
+    addCacheConfig(m, filterCacheFactory, queryResultCacheFactory, documentCacheFactory, fieldValueCacheFactory);
     m = new LinkedHashMap();
     result.put("requestDispatcher", m);
     m.put("handleSelect", handleSelect);
@@ -938,9 +937,9 @@ public class SolrConfig extends XmlConfigFile implements MapSerializable {
     return result;
   }
 
-  private void addCacheConfig(Map queryMap, CacheConfig... cache) {
+  private void addCacheConfig(Map queryMap, SolrCacheHolder.Factory... cache) {
     if (cache == null) return;
-    for (CacheConfig config : cache) if (config != null) queryMap.put(config.getNodeName(), config);
+    for (SolrCacheHolder.Factory config : cache) if (config != null) queryMap.put(config.getName(), config);
 
   }
 
diff --git a/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java b/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java
new file mode 100644
index 0000000..11bbd49
--- /dev/null
+++ b/solr/core/src/java/org/apache/solr/search/SolrCacheHolder.java
@@ -0,0 +1,179 @@
+/*
+ * 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.solr.search;
+
+import javax.xml.xpath.XPathConstants;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.apache.lucene.analysis.util.ResourceLoader;
+import org.apache.solr.common.MapWriter;
+import org.apache.solr.common.SolrException;
+import org.apache.solr.core.ConfigOverlay;
+import org.apache.solr.core.SolrConfig;
+import org.apache.solr.core.SolrCore;
+import org.apache.solr.util.DOMUtil;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import static org.apache.solr.common.params.CommonParams.NAME;
+
+public class SolrCacheHolder<K, V> {
+
+
+  protected volatile SolrCache<K, V> delegate;
+
+  public SolrCacheHolder(SolrCache<K, V> delegate) {
+    this.delegate = delegate;
+  }
+
+  public int size() {
+    return delegate.size();
+  }
+
+  public V put(K key, V value) {
+    return delegate.put(key, value);
+
+  }
+
+  public V get(K key) {
+    return delegate.get(key);
+  }
+
+  public void clear() {
+    delegate.clear();
+  }
+
+  public SolrCache<K, V> get() {
+    return delegate;
+  }
+
+  public void close() {
+    delegate.close();
+  }
+
+
+  public void warm(SolrIndexSearcher searcher, SolrCacheHolder src) {
+    delegate.warm(searcher, src.get());
+  }
+
+  public String name() {
+    return delegate.name();
+  }
+
+  public static class Factory implements MapWriter {
+    final Map<String, String> args;
+    private CacheRegenerator defRegen;
+    private final String name;
+    private String cacheImpl, regenImpl;
+    private Object[] persistence = new Object[1];
+
+
+    public Factory(Map<String, String> args) {
+      this.args = copyValsAsString(args);
+      this.name = args.get(NAME);
+      this.cacheImpl = args.getOrDefault("class", "solr.LRUCache");
+      this.regenImpl = args.get("regenerator");
+    }
+    static Map<String,String> copyValsAsString(Map m){
+      Map<String,String> copy = new LinkedHashMap(m.size());
+      m.forEach((k, v) -> copy.put(String.valueOf(k), String.valueOf(v)));
+      return copy;
+    }
+
+    public static Factory create(SolrConfig solrConfig, String xpath) {
+      Node node = solrConfig.getNode(xpath, false);
+      if (node == null || !"true".equals(DOMUtil.getAttrOrDefault(node, "enabled", "true"))) {
+        Map<String, String> m = solrConfig.getOverlay().getEditableSubProperties(xpath);
+        if (m == null) return null;
+        return new Factory(m);
+      } else {
+        Map<String, String> attrs = DOMUtil.toMap(node.getAttributes());
+        attrs.put(NAME, node.getNodeName());
+        return new Factory(applyOverlay(xpath, solrConfig.getOverlay(), attrs));
+
+      }
+
+
+    }
+
+    private static Map applyOverlay(String xpath, ConfigOverlay overlay, Map args) {
+      Map<String, String> map = xpath == null ? null : overlay.getEditableSubProperties(xpath);
+      if (map != null) {
+        HashMap<String, String> mapCopy = new HashMap<>(args);
+        for (Map.Entry<String, String> e : map.entrySet()) {
+          mapCopy.put(e.getKey(), String.valueOf(e.getValue()));
+        }
+        return mapCopy;
+      }
+      return args;
+    }
+
+    public static Map<String, Factory> create(SolrConfig solrConfig, String configPath, boolean multiple) {
+      NodeList nodes = (NodeList) solrConfig.evaluate(configPath, XPathConstants.NODESET);
+      if (nodes == null || nodes.getLength() == 0) return new LinkedHashMap<>();
+      Map<String, Factory> result = new HashMap<>(nodes.getLength());
+      for (int i = 0; i < nodes.getLength(); i++) {
+        Map<String, String> args = DOMUtil.toMap(nodes.item(i).getAttributes());
+        result.put(args.get(NAME), new Factory(args));
+      }
+      return result;
+    }
+
+    public String getName() {
+      return name;
+    }
+
+
+    public <K, V> SolrCacheHolder<K, V> create(SolrCore core) {
+      ResourceLoader loader = core.getResourceLoader();
+
+      SolrCache inst = null;
+      CacheRegenerator regen = null;
+      try {
+        inst = loader.findClass(cacheImpl, SolrCache.class).getConstructor().newInstance();
+        regen = null;
+        if (regenImpl != null) {
+          regen = loader.findClass(regenImpl, CacheRegenerator.class).getConstructor().newInstance();
+        }
+      } catch (Exception e) {
+        throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Error loading cache " + jsonStr(), e);
+
+      }
+      if (regen == null && defRegen != null) regen = defRegen;
+
+      inst.init(args, persistence[0], regen);
+
+
+      return new SolrCacheHolder<>(inst);
+
+    }
+
+    public void setDefaultRegenerator(CacheRegenerator regen) {
+      this.defRegen = regen;
+
+    }
+
+    @Override
+    public void writeMap(EntryWriter ew) throws IOException {
+      args.forEach(ew.getBiConsumer());
+    }
+  }
+}
diff --git a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
index 313d91b..d07c013 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrDocumentFetcher.java
@@ -86,7 +86,7 @@ public class SolrDocumentFetcher {
 
   private final boolean enableLazyFieldLoading;
 
-  private final SolrCache<Integer,Document> documentCache;
+  private final SolrCacheHolder<Integer,Document> documentCache;
 
   private final Set<String> allStored;
 
@@ -111,7 +111,8 @@ public class SolrDocumentFetcher {
     this.searcher = searcher;
     this.enableLazyFieldLoading = solrConfig.enableLazyFieldLoading;
     if (cachingEnabled) {
-      documentCache = solrConfig.documentCacheConfig == null ? null : solrConfig.documentCacheConfig.newInstance();
+      documentCache = solrConfig.documentCacheFactory == null ? null :
+          solrConfig.documentCacheFactory.create(searcher.getCore());
     } else {
       documentCache = null;
     }
@@ -174,7 +175,7 @@ public class SolrDocumentFetcher {
     return enableLazyFieldLoading;
   }
 
-  public SolrCache<Integer, Document> getDocumentCache() {
+  public SolrCacheHolder<Integer, Document> getDocumentCache() {
     return documentCache;
   }
 
diff --git a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
index 8b121e0..9edf2ae 100644
--- a/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
+++ b/solr/core/src/java/org/apache/solr/search/SolrIndexSearcher.java
@@ -97,8 +97,8 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
   // These should *only* be used for debugging or monitoring purposes
   public static final AtomicLong numOpens = new AtomicLong();
   public static final AtomicLong numCloses = new AtomicLong();
-  private static final Map<String,SolrCache> NO_GENERIC_CACHES = Collections.emptyMap();
-  private static final SolrCache[] NO_CACHES = new SolrCache[0];
+  private static final Map<String, SolrCacheHolder> NO_GENERIC_CACHES = Collections.emptyMap();
+  private static final SolrCacheHolder[] NO_CACHES = new SolrCacheHolder[0];
 
   private final SolrCore core;
   private final IndexSchema schema;
@@ -117,15 +117,15 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
   private final boolean useFilterForSortedQuery;
 
   private final boolean cachingEnabled;
-  private final SolrCache<Query,DocSet> filterCache;
-  private final SolrCache<QueryResultKey,DocList> queryResultCache;
-  private final SolrCache<String,UnInvertedField> fieldValueCache;
+  private final SolrCacheHolder<Query, DocSet> filterCache;
+  private final SolrCacheHolder<QueryResultKey, DocList> queryResultCache;
+  private final SolrCacheHolder<String, UnInvertedField> fieldValueCache;
 
   // map of generic caches - not synchronized since it's read-only after the constructor.
-  private final Map<String,SolrCache> cacheMap;
+  private final Map<String, SolrCacheHolder> cacheMap;
 
   // list of all caches associated with this searcher.
-  private final SolrCache[] cacheList;
+  private final SolrCacheHolder[] cacheList;
 
   private DirectoryFactory directoryFactory;
 
@@ -266,24 +266,24 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
 
     this.cachingEnabled = enableCache;
     if (cachingEnabled) {
-      final ArrayList<SolrCache> clist = new ArrayList<>();
-      fieldValueCache = solrConfig.fieldValueCacheConfig == null ? null
-          : solrConfig.fieldValueCacheConfig.newInstance();
-      if (fieldValueCache != null) clist.add(fieldValueCache);
-      filterCache = solrConfig.filterCacheConfig == null ? null : solrConfig.filterCacheConfig.newInstance();
+      final ArrayList<SolrCacheHolder> clist = new ArrayList<>();
+      fieldValueCache = solrConfig.fieldValueCacheFactory == null ? null
+          : solrConfig.fieldValueCacheFactory.create(core);
+      if (fieldValueCache != null) clist.add( fieldValueCache);
+      filterCache = solrConfig.filterCacheFactory == null ? null : solrConfig.filterCacheFactory.create(core);
       if (filterCache != null) clist.add(filterCache);
-      queryResultCache = solrConfig.queryResultCacheConfig == null ? null
-          : solrConfig.queryResultCacheConfig.newInstance();
+      queryResultCache = solrConfig.queryResultCacheFactory == null ? null
+          : solrConfig.queryResultCacheFactory.create(core);
       if (queryResultCache != null) clist.add(queryResultCache);
-      SolrCache<Integer, Document> documentCache = docFetcher.getDocumentCache();
+      SolrCacheHolder<Integer, Document> documentCache = docFetcher.getDocumentCache();
       if (documentCache != null) clist.add(documentCache);
 
-      if (solrConfig.userCacheConfigs.isEmpty()) {
+      if (solrConfig.userCacheFactory.isEmpty()) {
         cacheMap = NO_GENERIC_CACHES;
       } else {
-        cacheMap = new HashMap<>(solrConfig.userCacheConfigs.size());
-        for (Map.Entry<String,CacheConfig> e : solrConfig.userCacheConfigs.entrySet()) {
-          SolrCache cache = e.getValue().newInstance();
+        cacheMap = new HashMap<>(solrConfig.userCacheFactory.size());
+        for (Map.Entry<String, SolrCacheHolder.Factory> e : solrConfig.userCacheFactory.entrySet()) {
+          SolrCacheHolder cache = e.getValue().create(core);
           if (cache != null) {
             cacheMap.put(cache.name(), cache);
             clist.add(cache);
@@ -291,7 +291,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
         }
       }
 
-      cacheList = clist.toArray(new SolrCache[clist.size()]);
+      cacheList = clist.toArray(new SolrCacheHolder[clist.size()]);
     } else {
       this.filterCache = null;
       this.queryResultCache = null;
@@ -419,14 +419,14 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
     // register self
     infoRegistry.put(STATISTICS_KEY, this);
     infoRegistry.put(name, this);
-    for (SolrCache cache : cacheList) {
-      cache.setState(SolrCache.State.LIVE);
-      infoRegistry.put(cache.name(), cache);
+    for (SolrCacheHolder cache : cacheList) {
+      cache.get().setState(SolrCache.State.LIVE);
+      infoRegistry.put(cache.get().name(), cache.get());
     }
     metricManager = core.getCoreContainer().getMetricManager();
     registryName = core.getCoreMetricManager().getRegistryName();
-    for (SolrCache cache : cacheList) {
-      cache.initializeMetrics(metricManager, registryName, core.getMetricTag(), SolrMetricManager.mkName(cache.name(), STATISTICS_KEY));
+    for (SolrCacheHolder cache : cacheList) {
+      cache.get(). initializeMetrics(metricManager, registryName, core.getMetricTag(), SolrMetricManager.mkName(cache.name(), STATISTICS_KEY));
     }
     initializeMetrics(metricManager, registryName, core.getMetricTag(), STATISTICS_KEY);
     registerTime = new Date();
@@ -443,7 +443,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
       if (cachingEnabled) {
         final StringBuilder sb = new StringBuilder();
         sb.append("Closing ").append(name);
-        for (SolrCache cache : cacheList) {
+        for (SolrCacheHolder cache : cacheList) {
           sb.append("\n\t");
           sb.append(cache);
         }
@@ -470,7 +470,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
       core.getDeletionPolicy().releaseCommitPoint(cpg);
     }
 
-    for (SolrCache cache : cacheList) {
+    for (SolrCacheHolder cache : cacheList) {
       cache.close();
     }
 
@@ -495,71 +495,60 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
     return Iterables.transform(getFieldInfos(), fieldInfo -> fieldInfo.name);
   }
 
-  public SolrCache<Query,DocSet> getFilterCache() {
+  public SolrCacheHolder<Query,DocSet> getFilterCache() {
     return filterCache;
   }
 
   //
   // Set default regenerators on filter and query caches if they don't have any
   //
+
   public static void initRegenerators(SolrConfig solrConfig) {
-    if (solrConfig.fieldValueCacheConfig != null && solrConfig.fieldValueCacheConfig.getRegenerator() == null) {
-      solrConfig.fieldValueCacheConfig.setRegenerator(new CacheRegenerator() {
-        @Override
-        public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
-            Object oldKey, Object oldVal) throws IOException {
-          if (oldVal instanceof UnInvertedField) {
-            UnInvertedField.getUnInvertedField((String) oldKey, newSearcher);
-          }
-          return true;
+    if (solrConfig.fieldValueCacheFactory != null) {
+      solrConfig.fieldValueCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+        if (oldVal instanceof UnInvertedField) {
+          UnInvertedField.getUnInvertedField((String) oldKey, newSearcher);
         }
+        return true;
       });
     }
 
-    if (solrConfig.filterCacheConfig != null && solrConfig.filterCacheConfig.getRegenerator() == null) {
-      solrConfig.filterCacheConfig.setRegenerator(new CacheRegenerator() {
-        @Override
-        public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
-            Object oldKey, Object oldVal) throws IOException {
-          newSearcher.cacheDocSet((Query) oldKey, null, false);
-          return true;
-        }
+    if (solrConfig.filterCacheFactory != null ) {
+      solrConfig.filterCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+        newSearcher.cacheDocSet((Query) oldKey, null, false);
+        return true;
       });
     }
 
-    if (solrConfig.queryResultCacheConfig != null && solrConfig.queryResultCacheConfig.getRegenerator() == null) {
+    if (solrConfig.queryResultCacheFactory != null ) {
       final int queryResultWindowSize = solrConfig.queryResultWindowSize;
-      solrConfig.queryResultCacheConfig.setRegenerator(new CacheRegenerator() {
-        @Override
-        public boolean regenerateItem(SolrIndexSearcher newSearcher, SolrCache newCache, SolrCache oldCache,
-            Object oldKey, Object oldVal) throws IOException {
-          QueryResultKey key = (QueryResultKey) oldKey;
-          int nDocs = 1;
-          // request 1 doc and let caching round up to the next window size...
-          // unless the window size is <=1, in which case we will pick
-          // the minimum of the number of documents requested last time and
-          // a reasonable number such as 40.
-          // TODO: make more configurable later...
-
-          if (queryResultWindowSize <= 1) {
-            DocList oldList = (DocList) oldVal;
-            int oldnDocs = oldList.offset() + oldList.size();
-            // 40 has factors of 2,4,5,10,20
-            nDocs = Math.min(oldnDocs, 40);
-          }
-
-          int flags = NO_CHECK_QCACHE | key.nc_flags;
-          QueryCommand qc = new QueryCommand();
-          qc.setQuery(key.query)
-              .setFilterList(key.filters)
-              .setSort(key.sort)
-              .setLen(nDocs)
-              .setSupersetMaxDoc(nDocs)
-              .setFlags(flags);
-          QueryResult qr = new QueryResult();
-          newSearcher.getDocListC(qr, qc);
-          return true;
+      solrConfig.queryResultCacheFactory.setDefaultRegenerator((newSearcher, newCache, oldCache, oldKey, oldVal) -> {
+        QueryResultKey key = (QueryResultKey) oldKey;
+        int nDocs = 1;
+        // request 1 doc and let caching round up to the next window size...
+        // unless the window size is <=1, in which case we will pick
+        // the minimum of the number of documents requested last time and
+        // a reasonable number such as 40.
+        // TODO: make more configurable later...
+
+        if (queryResultWindowSize <= 1) {
+          DocList oldList = (DocList) oldVal;
+          int oldnDocs = oldList.offset() + oldList.size();
+          // 40 has factors of 2,4,5,10,20
+          nDocs = Math.min(oldnDocs, 40);
         }
+
+        int flags = NO_CHECK_QCACHE | key.nc_flags;
+        QueryCommand qc = new QueryCommand();
+        qc.setQuery(key.query)
+            .setFilterList(key.filters)
+            .setSort(key.sort)
+            .setLen(nDocs)
+            .setSupersetMaxDoc(nDocs)
+            .setFlags(flags);
+        QueryResult qr = new QueryResult();
+        newSearcher.getDocListC(qr, qc);
+        return true;
       });
     }
   }
@@ -624,7 +613,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
 
   /** expert: internal API, subject to change */
   public SolrCache<String,UnInvertedField> getFieldValueCache() {
-    return fieldValueCache;
+    return fieldValueCache == null? null : fieldValueCache.get();
   }
 
   /** Returns a weighted sort according to this searcher */
@@ -2184,14 +2173,15 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
    * return the named generic cache
    */
   public SolrCache getCache(String cacheName) {
-    return cacheMap.get(cacheName);
+    SolrCacheHolder holder = cacheMap.get(cacheName);
+    return holder == null ?null: holder.get();
   }
 
   /**
    * lookup an entry in a generic cache
    */
   public Object cacheLookup(String cacheName, Object key) {
-    SolrCache cache = cacheMap.get(cacheName);
+    SolrCacheHolder cache = cacheMap.get(cacheName);
     return cache == null ? null : cache.get(key);
   }
 
@@ -2199,7 +2189,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
    * insert an entry in a generic cache
    */
   public Object cacheInsert(String cacheName, Object key, Object val) {
-    SolrCache cache = cacheMap.get(cacheName);
+    SolrCacheHolder cache = cacheMap.get(cacheName);
     return cache == null ? null : cache.put(key, val);
   }
 
@@ -2469,7 +2459,7 @@ public class SolrIndexSearcher extends IndexSearcher implements Closeable, SolrI
 
     @Override
     public int hashCode() {
-      return classHash() 
+      return classHash()
           + 31 * Objects.hashCode(topFilter)
           + 31 * Objects.hashCode(weights);
     }
diff --git a/solr/core/src/test/org/apache/solr/core/TestConfig.java b/solr/core/src/test/org/apache/solr/core/TestConfig.java
index 69882c6..a94f2a4 100644
--- a/solr/core/src/test/org/apache/solr/core/TestConfig.java
+++ b/solr/core/src/test/org/apache/solr/core/TestConfig.java
@@ -111,27 +111,27 @@ public class TestConfig extends SolrTestCaseJ4 {
  public void testCacheEnablingDisabling() throws Exception {
    // ensure if cache is not defined in the config then cache is disabled 
    SolrConfig sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-defaults.xml", null);
-   assertNull(sc.filterCacheConfig);
-   assertNull(sc.queryResultCacheConfig);
-   assertNull(sc.documentCacheConfig);
+   assertNull(sc.filterCacheFactory);
+   assertNull(sc.queryResultCacheFactory);
+   assertNull(sc.documentCacheFactory);
    
    // enable all the caches via system properties and verify 
    System.setProperty("filterCache.enabled", "true");
    System.setProperty("queryResultCache.enabled", "true");
    System.setProperty("documentCache.enabled", "true");
    sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-cache-enable-disable.xml", null);
-   assertNotNull(sc.filterCacheConfig);
-   assertNotNull(sc.queryResultCacheConfig);
-   assertNotNull(sc.documentCacheConfig);
+   assertNotNull(sc.filterCacheFactory);
+   assertNotNull(sc.queryResultCacheFactory);
+   assertNotNull(sc.documentCacheFactory);
    
    // disable all the caches via system properties and verify
    System.setProperty("filterCache.enabled", "false");
    System.setProperty("queryResultCache.enabled", "false");
    System.setProperty("documentCache.enabled", "false");
    sc = new SolrConfig(new SolrResourceLoader(TEST_PATH().resolve("collection1")), "solrconfig-cache-enable-disable.xml", null);
-   assertNull(sc.filterCacheConfig);
-   assertNull(sc.queryResultCacheConfig);
-   assertNull(sc.documentCacheConfig);
+   assertNull(sc.filterCacheFactory);
+   assertNull(sc.queryResultCacheFactory);
+   assertNull(sc.documentCacheFactory);
    
    System.clearProperty("filterCache.enabled");
    System.clearProperty("queryResultCache.enabled");