示例#1
0
 private void deleteCloud(DeleteUpdateCommand cmd) throws IOException {
   UpdateRequestProcessorChain updateChain =
       xqueryComponent.getCore().getUpdateProcessingChain("lux-update-chain");
   SolrQueryResponse rsp = new SolrQueryResponse();
   SolrQueryRequest req = UpdateDocCommand.makeSolrRequest(core);
   UpdateRequestProcessor processor = updateChain.createProcessor(req, rsp);
   processor.processDelete(cmd);
   processor.finish();
 }
 @Test
 public void testProcessorConfiguration() {
   SolrCore core = h.getCore();
   UpdateRequestProcessorChain chained = core.getUpdateProcessingChain("uima");
   assertNotNull(chained);
   UIMAUpdateRequestProcessorFactory factory =
       (UIMAUpdateRequestProcessorFactory) chained.getFactories()[0];
   assertNotNull(factory);
 }
  // Skip encoding for updating the index
  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();
      cmd.solrDoc = doc;
      processor.processAdd(cmd);
    }
    processor.finish();
    req.close();

    assertU(commit());

    req = lrf.makeRequest();
    assertEquals(nDocs, req.getSearcher().maxDoc());
    req.close();
  }
示例#4
0
 private void writeToCloud(SolrInputDocument solrDoc, String uri) {
   ArrayList<String> urls = xqueryComponent.getShardURLs(true);
   LoggerFactory.getLogger(getClass()).debug("writing " + uri + " to cloud at " + urls);
   SolrQueryResponse rsp = new SolrQueryResponse();
   SolrQueryRequest req = UpdateDocCommand.makeSolrRequest(core);
   ((ModifiableSolrParams) req.getParams())
       .add(ShardParams.SHARDS, urls.toArray(new String[urls.size()]));
   UpdateRequest updateReq = new UpdateRequest();
   updateReq.add(solrDoc);
   UpdateDocCommand cmd = new UpdateDocCommand(req, solrDoc, null, uri);
   UpdateRequestProcessorChain updateChain =
       xqueryComponent.getCore().getUpdateProcessingChain("lux-update-chain");
   try {
     UpdateRequestProcessor processor = updateChain.createProcessor(req, rsp);
     processor.processAdd(cmd);
     processor.finish();
   } catch (IOException e) {
     throw new LuxException(e);
   }
 }
  protected boolean handleMergeAction(SolrQueryRequest req, SolrQueryResponse rsp)
      throws IOException {
    SolrParams params = req.getParams();
    String cname = params.required().get(CoreAdminParams.CORE);
    SolrCore core = coreContainer.getCore(cname);

    SolrCore[] sourceCores = null;
    RefCounted<SolrIndexSearcher>[] searchers = null;
    // stores readers created from indexDir param values
    IndexReader[] readersToBeClosed = null;
    if (core != null) {
      try {
        String[] dirNames = params.getParams(CoreAdminParams.INDEX_DIR);
        if (dirNames == null || dirNames.length == 0) {
          String[] sources = params.getParams("srcCore");
          if (sources == null || sources.length == 0)
            throw new SolrException(
                SolrException.ErrorCode.BAD_REQUEST,
                "At least one indexDir or srcCore must be specified");

          sourceCores = new SolrCore[sources.length];
          for (int i = 0; i < sources.length; i++) {
            String source = sources[i];
            SolrCore srcCore = coreContainer.getCore(source);
            if (srcCore == null)
              throw new SolrException(
                  SolrException.ErrorCode.BAD_REQUEST, "Core: " + source + " does not exist");
            sourceCores[i] = srcCore;
          }
        } else {
          readersToBeClosed = new IndexReader[dirNames.length];
          DirectoryFactory dirFactory = core.getDirectoryFactory();
          for (int i = 0; i < dirNames.length; i++) {
            readersToBeClosed[i] = IndexReader.open(dirFactory.open(dirNames[i]), true);
          }
        }

        IndexReader[] readers = null;
        if (readersToBeClosed != null) {
          readers = readersToBeClosed;
        } else {
          readers = new IndexReader[sourceCores.length];
          searchers = new RefCounted[sourceCores.length];
          for (int i = 0; i < sourceCores.length; i++) {
            SolrCore solrCore = sourceCores[i];
            // record the searchers so that we can decref
            searchers[i] = solrCore.getSearcher();
            readers[i] = searchers[i].get().getIndexReader();
          }
        }

        UpdateRequestProcessorChain processorChain =
            core.getUpdateProcessingChain(params.get(UpdateParams.UPDATE_CHAIN));
        SolrQueryRequest wrappedReq = new LocalSolrQueryRequest(core, req.getParams());
        UpdateRequestProcessor processor = processorChain.createProcessor(wrappedReq, rsp);

        processor.processMergeIndexes(new MergeIndexesCommand(readers));
      } finally {
        if (searchers != null) {
          for (RefCounted<SolrIndexSearcher> searcher : searchers) {
            if (searcher != null) searcher.decref();
          }
        }
        if (sourceCores != null) {
          for (SolrCore solrCore : sourceCores) {
            if (solrCore != null) solrCore.close();
          }
        }
        if (readersToBeClosed != null) IOUtils.closeWhileHandlingException(readersToBeClosed);
        core.close();
      }
    }
    return coreContainer.isPersistent();
  }