Examples with UpdateRequestProcessor org.apache.solr.update.processor.UpdateRequestProcessor used on opensource projects

Example 6 with UpdateRequestProcessor

use of org.apache.solr.update.processor.UpdateRequestProcessor in project lucene-solr by apache.

the class DefaultValueUpdateProcessorTest method processAdd.

/**
   * 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();
    }
}

Example 7 with UpdateRequestProcessor

use of org.apache.solr.update.processor.UpdateRequestProcessor in project lucene-solr by apache.

the class ContentStreamHandlerBase method handleRequestBody.

@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
    SolrParams params = req.getParams();
    UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessorChain(params);
    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
        try {
            processor.finish();
        } finally {
            processor.close();
        }
    }
}

Example 8 with UpdateRequestProcessor

use of org.apache.solr.update.processor.UpdateRequestProcessor in project lucene-solr by apache.

the class PeerSync method handleUpdates.

private boolean handleUpdates(ShardResponse srsp) {
    // we retrieved the last N updates from the replica
    List<Object> updates = (List<Object>) srsp.getSolrResponse().getResponse().get("updates");
    SyncShardRequest sreq = (SyncShardRequest) srsp.getShardRequest();
    if (updates.size() < sreq.totalRequestedUpdates) {
        log.error(msg() + " Requested " + sreq.totalRequestedUpdates + " updates from " + sreq.shards[0] + " but retrieved " + updates.size());
        return false;
    }
    // overwrite fingerprint we saved in 'handleVersions()'   
    Object fingerprint = srsp.getSolrResponse().getResponse().get("fingerprint");
    if (fingerprint != null) {
        sreq.fingerprint = IndexFingerprint.fromObject(fingerprint);
    }
    ModifiableSolrParams params = new ModifiableSolrParams();
    params.set(DISTRIB_UPDATE_PARAM, FROMLEADER.toString());
    // debugging
    params.set("peersync", true);
    SolrQueryRequest req = new LocalSolrQueryRequest(uhandler.core, params);
    SolrQueryResponse rsp = new SolrQueryResponse();
    UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessingChain(null);
    UpdateRequestProcessor proc = processorChain.createProcessor(req, rsp);
    Collections.sort(updates, updateRecordComparator);
    Object o = null;
    long lastVersion = 0;
    try {
        // Apply oldest updates first
        for (Object obj : updates) {
            // should currently be a List<Oper,Ver,Doc/Id>
            o = obj;
            List<Object> entry = (List<Object>) o;
            if (debug) {
                log.debug(msg() + "raw update record " + o);
            }
            int oper = (Integer) entry.get(0) & UpdateLog.OPERATION_MASK;
            long version = (Long) entry.get(1);
            if (version == lastVersion && version != 0)
                continue;
            lastVersion = version;
            switch(oper) {
                case UpdateLog.ADD:
                    {
                        // byte[] idBytes = (byte[]) entry.get(2);
                        SolrInputDocument sdoc = (SolrInputDocument) entry.get(entry.size() - 1);
                        AddUpdateCommand cmd = new AddUpdateCommand(req);
                        // cmd.setIndexedId(new BytesRef(idBytes));
                        cmd.solrDoc = sdoc;
                        cmd.setVersion(version);
                        cmd.setFlags(UpdateCommand.PEER_SYNC | UpdateCommand.IGNORE_AUTOCOMMIT);
                        if (debug) {
                            log.debug(msg() + "add " + cmd + " id " + sdoc.getField(ID));
                        }
                        proc.processAdd(cmd);
                        break;
                    }
                case UpdateLog.DELETE:
                    {
                        byte[] idBytes = (byte[]) entry.get(2);
                        DeleteUpdateCommand cmd = new DeleteUpdateCommand(req);
                        cmd.setIndexedId(new BytesRef(idBytes));
                        cmd.setVersion(version);
                        cmd.setFlags(UpdateCommand.PEER_SYNC | UpdateCommand.IGNORE_AUTOCOMMIT);
                        if (debug) {
                            log.debug(msg() + "delete " + cmd + " " + new BytesRef(idBytes).utf8ToString());
                        }
                        proc.processDelete(cmd);
                        break;
                    }
                case UpdateLog.DELETE_BY_QUERY:
                    {
                        String query = (String) entry.get(2);
                        DeleteUpdateCommand cmd = new DeleteUpdateCommand(req);
                        cmd.query = query;
                        cmd.setVersion(version);
                        cmd.setFlags(UpdateCommand.PEER_SYNC | UpdateCommand.IGNORE_AUTOCOMMIT);
                        if (debug) {
                            log.debug(msg() + "deleteByQuery " + cmd);
                        }
                        proc.processDelete(cmd);
                        break;
                    }
                case UpdateLog.UPDATE_INPLACE:
                    {
                        AddUpdateCommand cmd = UpdateLog.convertTlogEntryToAddUpdateCommand(req, entry, oper, version);
                        cmd.setFlags(UpdateCommand.PEER_SYNC | UpdateCommand.IGNORE_AUTOCOMMIT);
                        if (debug) {
                            log.debug(msg() + "inplace update " + cmd + " prevVersion=" + cmd.prevVersion + ", doc=" + cmd.solrDoc);
                        }
                        proc.processAdd(cmd);
                        break;
                    }
                default:
                    throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Unknown Operation! " + oper);
            }
        }
    } catch (IOException e) {
        // TODO: should this be handled separately as a problem with us?
        // I guess it probably already will by causing replication to be kicked off.
        sreq.updateException = e;
        log.error(msg() + "Error applying updates from " + sreq.shards + " ,update=" + o, e);
        return false;
    } catch (Exception e) {
        sreq.updateException = e;
        log.error(msg() + "Error applying updates from " + sreq.shards + " ,update=" + o, e);
        return false;
    } finally {
        try {
            proc.finish();
        } catch (Exception e) {
            sreq.updateException = e;
            log.error(msg() + "Error applying updates from " + sreq.shards + " ,finish()", e);
            return false;
        } finally {
            IOUtils.closeQuietly(proc);
        }
    }
    return compareFingerprint(sreq);
}

Example 9 with UpdateRequestProcessor

use of org.apache.solr.update.processor.UpdateRequestProcessor in project lucene-solr by apache.

the class BlobHandler method indexMap.

public static void indexMap(SolrQueryRequest req, SolrQueryResponse rsp, Map<String, Object> doc) throws IOException {
    SolrInputDocument solrDoc = new SolrInputDocument();
    for (Map.Entry<String, Object> e : doc.entrySet()) solrDoc.addField(e.getKey(), e.getValue());
    UpdateRequestProcessorChain processorChain = req.getCore().getUpdateProcessorChain(req.getParams());
    try (UpdateRequestProcessor processor = processorChain.createProcessor(req, rsp)) {
        AddUpdateCommand cmd = new AddUpdateCommand(req);
        cmd.solrDoc = solrDoc;
        log.info("Adding doc: " + doc);
        processor.processAdd(cmd);
        log.info("committing doc: " + doc);
        processor.processCommit(new CommitUpdateCommand(req, false));
        processor.finish();
    }
}

Example 10 with UpdateRequestProcessor

use of org.apache.solr.update.processor.UpdateRequestProcessor in project lucene-solr by apache.

the class UIMAUpdateRequestProcessorTest method testMultiMap.

@Test
public void testMultiMap() {
    SolrCore core = h.getCore();
    UpdateRequestProcessorChain chained = core.getUpdateProcessingChain(UIMA_MULTI_MAP_CHAIN);
    assertNotNull(chained);
    UIMAUpdateRequestProcessorFactory factory = (UIMAUpdateRequestProcessorFactory) chained.getProcessors().get(0);
    assertNotNull(factory);
    UpdateRequestProcessor processor = factory.getInstance(req(), null, null);
    assertTrue(processor instanceof UIMAUpdateRequestProcessor);
    SolrUIMAConfiguration conf = ((UIMAUpdateRequestProcessor) processor).getConfiguration();
    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));
}