/*
* 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 java.io.File;
import java.util.Collections;
import org.apache.commons.io.FileUtils;
import org.apache.solr.SolrTestCaseJ4;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.schema.IndexSchema;
import org.apache.solr.schema.ManagedIndexSchema;
import org.apache.solr.schema.SchemaField;
import org.junit.AfterClass;
import org.junit.BeforeClass;
/**
* Requests to open a new searcher w/o any underlying change to the index exposed
* by the current searcher should result in the same searcher being re-used.
*
* Likewise, if there <em>is</em> in fact an underlying index change, we want to
* assert that a new searcher will in fact be opened.
*/
public class TestSearcherReuse extends SolrTestCaseJ4 {
private static File solrHome;
private static final String collection = "collection1";
private static final String confPath = collection + "/conf";
/**
* We're using a Managed schema so we can confirm that opening a new searcher
* after a schema modification results in getting a new searcher with the new
* schema linked to it.
*/
@BeforeClass
private static void setupTempDirAndCoreWithManagedSchema() throws Exception {
solrHome = createTempDir().toFile();
solrHome = solrHome.getAbsoluteFile();
File confDir = new File(solrHome, confPath);
File testHomeConfDir = new File(TEST_HOME(), confPath);
FileUtils.copyFileToDirectory(new File(testHomeConfDir, "solrconfig-managed-schema.xml"), confDir);
FileUtils.copyFileToDirectory(new File(testHomeConfDir, "solrconfig.snippet.randomindexconfig.xml"), confDir);
FileUtils.copyFileToDirectory(new File(testHomeConfDir, "schema-id-and-version-fields-only.xml"), confDir);
// initCore will trigger an upgrade to managed schema, since the solrconfig has
// <schemaFactory class="ManagedIndexSchemaFactory" ... />
System.setProperty("managed.schema.mutable", "true");
initCore("solrconfig-managed-schema.xml", "schema-id-and-version-fields-only.xml",
solrHome.getPath());
}
@AfterClass
private static void afterClass() throws Exception {
solrHome = null;
}
@Override
public void tearDown() throws Exception {
super.tearDown();
assertU(delQ("*:*"));
optimize();
assertU(commit());
}
public void test() throws Exception {
// seed some docs & segments
int numDocs = atLeast(1);
for (int i = 1; i <= numDocs; i++) {
// NOTE: starting at "1", we'll use id=0 later
assertU(adoc("id", ""+i));
if (random().nextBoolean()) {
assertU(commit());
}
}
// with random merge policies, a regular commit can cause a segment to be flushed that can kick off a background merge
// that can cause a later commit to actually see changes and open a new searcher. This should not be possible with optimize
assertU(optimize());
// seed a single query into the cache
assertQ(req("*:*"), "//*[@numFound='"+numDocs+"']");
final SolrQueryRequest baseReq = req("q","foo");
try {
// we make no index changes in this block, so the searcher should always be the same
// NOTE: we *have* to call getSearcher() in advance, it's a delayed binding
final SolrIndexSearcher expectedSearcher = getMainSearcher(baseReq);
assertU(commit());
assertSearcherHasNotChanged(expectedSearcher);
assertU(commit("openSearcher","true"));
assertSearcherHasNotChanged(expectedSearcher);
assertU(commit("softCommit","true"));
assertSearcherHasNotChanged(expectedSearcher);
assertU(commit("softCommit","true","openSearcher","true"));
assertSearcherHasNotChanged(expectedSearcher);
assertU(delQ("id:match_no_documents"));
assertU(commit("softCommit","true","openSearcher","true"));
assertSearcherHasNotChanged(expectedSearcher);
assertU(delI("0")); // no doc has this id, yet
assertU(commit("softCommit","true","openSearcher","true"));
assertSearcherHasNotChanged(expectedSearcher);
} finally {
baseReq.close();
}
// now do a variety of things that *should* always guarantee a new searcher
SolrQueryRequest beforeReq;
beforeReq = req("q","foo");
try {
// NOTE: we *have* to call getSearcher() in advance: delayed binding
SolrIndexSearcher before = getMainSearcher(beforeReq);
assertU(delI("1"));
assertU(commit());
assertSearcherHasChanged(before);
} finally {
beforeReq.close();
}
beforeReq = req("q","foo");
try {
// NOTE: we *have* to call getSearcher() in advance: delayed binding
SolrIndexSearcher before = getMainSearcher(beforeReq);
assertU(adoc("id", "0"));
assertU(commit());
assertSearcherHasChanged(before);
} finally {
beforeReq.close();
}
beforeReq = req("q","foo");
try {
// NOTE: we *have* to call getSearcher() in advance: delayed binding
SolrIndexSearcher before = getMainSearcher(beforeReq);
assertU(delQ("id:[0 TO 5]"));
assertU(commit());
assertSearcherHasChanged(before);
} finally {
beforeReq.close();
}
beforeReq = req("q","foo");
try {
// NOTE: we *have* to call getSearcher() in advance: delayed binding
SolrIndexSearcher before = getMainSearcher(beforeReq);
// create a new field & add it.
assertTrue("schema not mutable", beforeReq.getSchema().isMutable());
ManagedIndexSchema oldSchema = (ManagedIndexSchema) beforeReq.getSchema();
SchemaField newField = oldSchema.newField
("hoss", "string", Collections.<String,Object>emptyMap());
IndexSchema newSchema = oldSchema.addField(newField);
h.getCore().setLatestSchema(newSchema);
// sanity check, later asserts assume this
assertNotSame(oldSchema, newSchema);
// the schema has changed - but nothing has requested a new Searcher yet
assertSearcherHasNotChanged(before);
// only now should we get a new searcher...
assertU(commit("softCommit","true","openSearcher","true"));
assertSearcherHasChanged(before);
// sanity that opening the new searcher was useful to get new schema...
SolrQueryRequest afterReq = req("q","foo");
try {
assertSame(newSchema, afterReq.getSchema());
assertSame(newSchema, getMainSearcher(afterReq).getSchema());
} finally {
afterReq.close();
}
} finally {
beforeReq.close();
}
}
/**
* Helper method to get the searcher from a request, and assert that it's the main searcher
*/
public static SolrIndexSearcher getMainSearcher(SolrQueryRequest req) {
SolrIndexSearcher s = req.getSearcher();
assertMainSearcher(s);
return s;
}
/**
* Sanity check that we didn't get a realtime (non-caching) searcher
*/
public static void assertMainSearcher(SolrIndexSearcher s) {
assertTrue("Searcher isn't 'main': " + s.toString(),
// TODO brittle, better solution?
s.toString().contains(" main{"));
assertTrue("Searcher is non-caching", s.isCachingEnabled());
}
/**
* Given an existing searcher, creates a new SolrRequest, and verifies that the
* searcher in that request is <b>not</b> the same as the previous searcher --
* cleaningly closing the new SolrRequest either way.
*/
public static void assertSearcherHasChanged(SolrIndexSearcher previous) {
SolrQueryRequest req = req("*:*");
try {
SolrIndexSearcher newSearcher = getMainSearcher(req);
assertNotSame(previous, newSearcher);
} finally {
req.close();
}
}
/**
* Given an existing searcher, creates a new SolrRequest, and verifies that the
* searcher in that request is the same as the expected searcher -- cleaningly
* closing the new SolrRequest either way.
*/
public static void assertSearcherHasNotChanged(SolrIndexSearcher expected) {
SolrQueryRequest req = req("*:*");
try {
SolrIndexSearcher newSearcher = getMainSearcher(req);
assertSame(expected, newSearcher);
} finally {
req.close();
}
}
}