Java UpdateRequestProcessorChain类代码示例

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Test
public void testMultiMap() {
  SolrCore core = h.getCore();
  UpdateRequestProcessorChain chained = core.getUpdateProcessingChain("uima-multi-map");
  assertNotNull(chained);
  UIMAUpdateRequestProcessorFactory factory = (UIMAUpdateRequestProcessorFactory) chained
          .getFactories()[0];
  assertNotNull(factory);
  UpdateRequestProcessor processor = factory.getInstance(req(), null, null);
  assertTrue(processor instanceof UIMAUpdateRequestProcessor);
  SolrUIMAConfiguration conf = ((UIMAUpdateRequestProcessor)processor).solrUIMAConfiguration;
  Map<String, Map<String, MapField>> map = conf.getTypesFeaturesFieldsMapping();
  Map<String, MapField> subMap = map.get("a-type-which-can-have-multiple-features");
  assertEquals(2, subMap.size());
  assertEquals("1", subMap.get("A").getFieldName(null));
  assertEquals("2", subMap.get("B").getFieldName(null));
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
public void testXInclude() throws Exception {
  SolrCore core = h.getCore();

  assertNotNull("includedHandler is null", 
                core.getRequestHandler("includedHandler"));

  UpdateRequestProcessorChain chain 
    = core.getUpdateProcessingChain("special-include");
  assertNotNull("chain is missing included processor", chain);
  assertEquals("chain with inclued processor is wrong size", 
               1, chain.getFactories().length);
  assertEquals("chain has wrong included processor",
               RegexReplaceProcessorFactory.class,
               chain.getFactories()[0].getClass());

  assertNotNull("ft-included is null",
                core.getSchema().getFieldTypeByName("ft-included"));
  assertNotNull("field-included is null",
                core.getSchema().getFieldOrNull("field-included"));
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Override
@SuppressWarnings("PMD.SignatureDeclareThrowsException")
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
    formatResponseAsJson(req);

    if (req.getContentStreams() == null) {
        LOGGER.warn("no content stream");
        rsp.add("error", "No content stream");
        return;
    }

    boolean commit = Boolean.parseBoolean(req.getParams().get("commit", "true"));

    InputStream stream = req.getContentStreams().iterator().next().getStream();
    stream = detectGzip(stream);

    MetricTimeSeriesConverter converter = new MetricTimeSeriesConverter();

    UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessorChain(req.getParams());
    UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp);
    try {
        for (MetricTimeSeries series : formatParser.parse(stream)) {
            SolrInputDocument document = new SolrInputDocument();
            converter.to(series).getFields().forEach(document::addField);
            storeDocument(document, processor, req);
        }

        if (commit) {
            LOGGER.debug("Committing transaction...");
            processor.processCommit(new CommitUpdateCommand(req, false));
            LOGGER.debug("Committed transaction");
        } else {
            LOGGER.debug("Only adding documents.");
        }
    } finally {
        processor.finish();
    }
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Test
public void testProcessorConfiguration() {
  SolrCore core = h.getCore();
  UpdateRequestProcessorChain chained = core.getUpdateProcessingChain("uima");
  assertNotNull(chained);
  UIMAUpdateRequestProcessorFactory factory = (UIMAUpdateRequestProcessorFactory) chained
          .getFactories()[0];
  assertNotNull(factory);
  UpdateRequestProcessor processor = factory.getInstance(req(), null, null);
  assertTrue(processor instanceof UIMAUpdateRequestProcessor);
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
  SolrParams params = req.getParams();
  UpdateRequestProcessorChain processorChain =
          req.getCore().getUpdateProcessingChain(params.get(UpdateParams.UPDATE_CHAIN));

  UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp);

  try {
    ContentStreamLoader documentLoader = newLoader(req, processor);


    Iterable<ContentStream> streams = req.getContentStreams();
    if (streams == null) {
      if (!RequestHandlerUtils.handleCommit(req, processor, params, false) && !RequestHandlerUtils.handleRollback(req, processor, params, false)) {
        throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "missing content stream");
      }
    } else {

      for (ContentStream stream : streams) {
        documentLoader.load(req, rsp, stream, processor);
      }

      // Perhaps commit from the parameters
      RequestHandlerUtils.handleCommit(req, processor, params, false);
      RequestHandlerUtils.handleRollback(req, processor, params, false);
    }
  } finally {
    // finish the request
    processor.finish();
  }
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
/**
 * @return an update processor registered to the given name.  Throw an exception if this chain is undefined
 */    
public UpdateRequestProcessorChain getUpdateProcessingChain( final String name )
{
  UpdateRequestProcessorChain chain = updateProcessorChains.get( name );
  if( chain == null ) {
    throw new SolrException( SolrException.ErrorCode.BAD_REQUEST,
        "unknown UpdateRequestProcessorChain: "+name );
  }
  return chain;
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
/**
 * Runs a document through the specified chain, and returns the final 
 * document used when the chain is completed (NOTE: some chains may 
 * modify the document in place
 */
SolrInputDocument processAdd(final String chain, 
                             final SolrInputDocument docIn) 
  throws IOException {

  SolrCore core = h.getCore();
  UpdateRequestProcessorChain pc = core.getUpdateProcessingChain(chain);
  assertNotNull("No Chain named: " + chain, pc);

  SolrQueryResponse rsp = new SolrQueryResponse();

  SolrQueryRequest req = new LocalSolrQueryRequest
    (core, new ModifiableSolrParams());
  try {
    SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req,rsp));
    AddUpdateCommand cmd = new AddUpdateCommand(req);
    cmd.solrDoc = docIn;

    UpdateRequestProcessor processor = pc.createProcessor(req, rsp);
    processor.processAdd(cmd);

    return cmd.solrDoc;
  } finally {
    SolrRequestInfo.clearRequestInfo();
    req.close();
  }
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
public void testXInclude() throws Exception {
  SolrCore core = h.getCore();

  assertNotNull("includedHandler is null", 
                core.getRequestHandler("includedHandler"));

  UpdateRequestProcessorChain chain 
    = core.getUpdateProcessingChain("special-include");
  assertNotNull("chain is missing included processor", chain);
  assertEquals("chain with inclued processor is wrong size", 
               1, chain.getFactories().length);
  assertEquals("chain has wrong included processor",
               RegexReplaceProcessorFactory.class,
               chain.getFactories()[0].getClass());

  IndexSchema schema = core.getLatestSchema();
  
  // xinclude
  assertNotNull("ft-included is null", schema.getFieldTypeByName("ft-included"));
  assertNotNull("field-included is null", schema.getFieldOrNull("field-included"));

  // entity include
  assertNotNull("ft-entity-include1 is null", 
                schema.getFieldTypeByName("ft-entity-include1"));
  assertNotNull("ft-entity-include2 is null", 
                schema.getFieldTypeByName("ft-entity-include2"));

  // sanity check
  assertNull("ft-entity-include3 is not null",  // Does Not Exist Anywhere
             schema.getFieldTypeByName("ft-entity-include3"));

}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Before
public void setUpBase() throws Exception
{
    coreContainer = new CoreContainer();
    coreDescriptor = new CoreDescriptor(coreContainer, "name", "instanceDir");
    when(resourceLoader.getCoreProperties()).thenReturn(new Properties());
    
    // SolrCore is final, we can't mock with mockito
    core = new SolrCore("name", coreDescriptor);
    FieldUtils.writeField(core, "updateHandler", updateHandler, true);
    FieldUtils.writeField(core, "resourceLoader", resourceLoader, true);
    infoRegistry = new HashMap<String, SolrInfoMBean>();
    FieldUtils.writeField(core, "infoRegistry", infoRegistry, true);
    reqHandlers = new RequestHandlers(core);
    reqHandlers.register("/select", selectRequestHandler);
    reqHandlers.register("/afts", aftsRequestHandler);
    FieldUtils.writeField(core, "reqHandlers", reqHandlers, true);

    Map<String, UpdateRequestProcessorChain> map = new HashMap<>();
    UpdateRequestProcessorFactory[] factories = new UpdateRequestProcessorFactory[] { runUpdateProcessorFactory };
    when(runUpdateProcessorFactory.getInstance(any(SolrQueryRequest.class), any(SolrQueryResponse.class),
                            any(UpdateRequestProcessor.class))).thenReturn(processor);
    UpdateRequestProcessorChain def = new UpdateRequestProcessorChain(factories, core);
    map.put(null, def);
    map.put("", def);
    FieldUtils.writeField(core, "updateProcessorChains", map, true);
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
/**
 * @return an update processor registered to the given name. Throw an exception if this chain is
 * undefined
 */
public UpdateRequestProcessorChain getUpdateProcessingChain(final String name) {
	UpdateRequestProcessorChain chain = updateProcessorChains.get(name);
	if(chain == null) {
		throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "unknown UpdateRequestProcessorChain: " + name);
	}
	return chain;
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
	// TODO Auto-generated method stub
	SolrParams params = req.getParams();

	String recordUrl = params.get("url");
	String searchLogDocId = params.get("searchLogDocId");
	String clickLogDocId = generateClickLogDocId(recordUrl, searchLogDocId);
	String collectionName = params.get("collectionName");
	String displayUrl = params.toString();

	SolrInputDocument doc = new SolrInputDocument();
	doc.setField(StatsConstants.INDEX_FIELD_ID, clickLogDocId);
	doc.setField(StatsConstants.INDEX_FIELD_COLLECTION_NAME, collectionName);
	doc.setField(StatsConstants.INDEX_FIELD_SEARCH_LOG_DOC_ID, searchLogDocId);
	doc.setField(StatsConstants.INDEX_FIELD_RECORD_URL, recordUrl);
	doc.setField(StatsConstants.INDEX_FIELD_DISPLAY_URL, displayUrl);
	doc.setField(StatsConstants.INDEX_FIELD_CLICK_DATE, new Date());

	UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessingChain(params.get(UpdateParams.UPDATE_CHAIN));

	UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp);
	try {
		AddUpdateCommand addCmd = new AddUpdateCommand(req);
		addCmd.commitWithin = params.getInt(UpdateParams.COMMIT_WITHIN, -1);
		addCmd.overwrite = params.getBool(UpdateParams.OVERWRITE, true);
		addCmd.solrDoc = doc;
		processor.processAdd(addCmd);
		// Perhaps commit from the parameters
		RequestHandlerUtils.handleCommit(req, processor, params, false);
		RequestHandlerUtils.handleRollback(req, processor, params, false);

	} finally {
		// finish the request
		processor.finish();
	}
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
public void testAutomaticDeletes() throws Exception {

    // get a handle on our recorder

    UpdateRequestProcessorChain chain = 
      h.getCore().getUpdateProcessingChain("scheduled-delete");

    assertNotNull(chain);

    UpdateRequestProcessorFactory[] factories = chain.getFactories();
    assertEquals("did number of processors configured in chain get changed?", 
                 5, factories.length);
    assertTrue("Expected [1] RecordingUpdateProcessorFactory: " + factories[1].getClass(),
               factories[1] instanceof RecordingUpdateProcessorFactory);
    RecordingUpdateProcessorFactory recorder = 
      (RecordingUpdateProcessorFactory) factories[1];

    // now start recording, and monitor for the expected commands

    try {
      recorder.startRecording();
      
      // more then one iter to verify it's recurring
      final int numItersToCheck = 1 + RANDOM_MULTIPLIER;
      
      for (int i = 0; i < numItersToCheck; i++) { 
        UpdateCommand tmp;
        
        // be generous in how long we wait, some jenkins machines are slooooow
        tmp = recorder.commandQueue.poll(30, TimeUnit.SECONDS);
        
        // we can be confident in the order because DocExpirationUpdateProcessorFactory
        // uses the same request for both the delete & the commit -- and both 
        // RecordingUpdateProcessorFactory's getInstance & startRecording methods are 
        // synchronized.  So it should not be possible to start recording in the 
        // middle of the two commands
        assertTrue("expected DeleteUpdateCommand: " + tmp.getClass(),
                   tmp instanceof DeleteUpdateCommand);
        
        DeleteUpdateCommand delete = (DeleteUpdateCommand) tmp;
        assertFalse(delete.isDeleteById());
        assertNotNull(delete.getQuery());
        assertTrue(delete.getQuery(), 
                   delete.getQuery().startsWith("{!cache=false}eXpField_tdt:[* TO "));
        
        // commit should be immediately after the delete
        tmp = recorder.commandQueue.poll(5, TimeUnit.SECONDS);
        assertTrue("expected CommitUpdateCommand: " + tmp.getClass(),
                   tmp instanceof CommitUpdateCommand);
        
        CommitUpdateCommand commit = (CommitUpdateCommand) tmp;
        assertTrue(commit.softCommit);
        assertTrue(commit.openSearcher);
      } 
    } finally {
      recorder.stopRecording();
    }
  }
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
void createIndex2(int nDocs, String... fields) throws IOException {
  Set<String> fieldSet = new HashSet<>(Arrays.asList(fields));

  SolrQueryRequest req = lrf.makeRequest();
  SolrQueryResponse rsp = new SolrQueryResponse();
  UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessingChain(null);
  UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp);

  boolean foomany_s = fieldSet.contains("foomany_s");
  boolean foo1_s = fieldSet.contains("foo1_s");
  boolean foo2_s = fieldSet.contains("foo2_s");
  boolean foo4_s = fieldSet.contains("foo4_s");
  boolean foo8_s = fieldSet.contains("foo8_s");
  boolean t10_100_ws = fieldSet.contains("t10_100_ws");

  
  for (int i=0; i<nDocs; i++) {
    SolrInputDocument doc = new SolrInputDocument();
    doc.addField("id",Float.toString(i));
    if (foomany_s) {
      doc.addField("foomany_s",t(r.nextInt(nDocs*10)));
    }
    if (foo1_s) {
      doc.addField("foo1_s",t(0));
    }
    if (foo2_s) {
      doc.addField("foo2_s",r.nextInt(2));
    }
    if (foo4_s) {
      doc.addField("foo4_s",r.nextInt(4));
    }
    if (foo8_s) {
      doc.addField("foo8_s",r.nextInt(8));
    }
    if (t10_100_ws) {
      StringBuilder sb = new StringBuilder(9*100);
      for (int j=0; j<100; j++) {
        sb.append(' ');
        sb.append(t(r.nextInt(10)));
      }
      doc.addField("t10_100_ws", sb.toString());
    }

    AddUpdateCommand cmd = new AddUpdateCommand(req);
    cmd.solrDoc = doc;
    processor.processAdd(cmd);
  }
  processor.finish();
  req.close();

  assertU(commit());

  req = lrf.makeRequest();
  assertEquals(nDocs, req.getSearcher().maxDoc());
  req.close();
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
public UpdateRequestProcessorChain getProcessorChain() {
  return this.processorChain;
}
 

import org.apache.solr.update.processor.UpdateRequestProcessorChain; //导入依赖的package包/类
void createIndex2(int nDocs, String... fields) throws IOException {
  Set<String> fieldSet = new HashSet<String>(Arrays.asList(fields));

  SolrQueryRequest req = lrf.makeRequest();
  SolrQueryResponse rsp = new SolrQueryResponse();
  UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessingChain(null);
  UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp);

  boolean foomany_s = fieldSet.contains("foomany_s");
  boolean foo1_s = fieldSet.contains("foo1_s");
  boolean foo2_s = fieldSet.contains("foo2_s");
  boolean foo4_s = fieldSet.contains("foo4_s");
  boolean foo8_s = fieldSet.contains("foo8_s");
  boolean t10_100_ws = fieldSet.contains("t10_100_ws");

  
  for (int i=0; i<nDocs; i++) {
    SolrInputDocument doc = new SolrInputDocument();
    doc.addField("id",Float.toString(i));
    if (foomany_s) {
      doc.addField("foomany_s",t(r.nextInt(nDocs*10)));
    }
    if (foo1_s) {
      doc.addField("foo1_s",t(0));
    }
    if (foo2_s) {
      doc.addField("foo2_s",r.nextInt(2));
    }
    if (foo4_s) {
      doc.addField("foo4_s",r.nextInt(4));
    }
    if (foo8_s) {
      doc.addField("foo8_s",r.nextInt(8));
    }
    if (t10_100_ws) {
      StringBuilder sb = new StringBuilder(9*100);
      for (int j=0; j<100; j++) {
        sb.append(' ');
        sb.append(t(r.nextInt(10)));
      }
      doc.addField("t10_100_ws", sb.toString());
    }

    AddUpdateCommand cmd = new AddUpdateCommand(req);
    cmd.solrDoc = doc;
    processor.processAdd(cmd);
  }
  processor.finish();
  req.close();

  assertU(commit());

  req = lrf.makeRequest();
  assertEquals(nDocs, req.getSearcher().maxDoc());
  req.close();
}