Java ConcurrentUpdateSolrServer类代码示例

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public XMLFilter getXMLFilter(ArgFactory arf, InputCommandFactory.InputCommand inputBase, CommandType maxType) {
    if (!init(parser.parse(arf.getArgs(parser.recognizedOptions().keySet())), inputBase)) {
        return null;
    }
    CommandFactory.conditionalInit(first, inputBase, EXPECT_INPUT);
    SAXSolrPoster ssp = new SAXSolrPoster();
    ssp.setServer(new ConcurrentUpdateSolrServer(solrURL, queueSize, threadCount));
    if (first && inputBase.getFilesFrom() != null) {
        ssp.setInputType(QueueSourceXMLFilter.InputType.indirect);
        if (inputBase.getDelim() != null) {
            ssp.setDelimiterPattern(Pattern.compile(inputBase.getDelim(), Pattern.LITERAL));
        }
    }
    return ssp;
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
private long testIndexingWithSuss(long docId) throws Exception {
  ConcurrentUpdateSolrServer suss = new ConcurrentUpdateSolrServer(
      ((HttpSolrServer) clients.get(0)).getBaseURL(), 10, 2);
  QueryResponse results = query(cloudClient);
  long beforeCount = results.getResults().getNumFound();
  int cnt = TEST_NIGHTLY ? 2933 : 313;
  try {
    suss.setConnectionTimeout(120000);
    for (int i = 0; i < cnt; i++) {
      index_specific(suss, id, docId++, "text_t", "some text so that it not's negligent work to parse this doc, even though it's still a pretty short doc");
    }
    suss.blockUntilFinished();
    
    commit();

    checkShardConsistency();
    assertDocCounts(VERBOSE);
  } finally {
    suss.shutdown();
  }
  results = query(cloudClient);
  assertEquals(beforeCount + cnt, results.getResults().getNumFound());
  return docId;
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
public FullThrottleStopableIndexingThread(List<SolrServer> clients,
    String id, boolean doDeletes) {
  super(controlClient, cloudClient, id, doDeletes);
  setName("FullThrottleStopableIndexingThread");
  setDaemon(true);
  this.clients = clients;
  HttpClientUtil.setConnectionTimeout(httpClient, 15000);
  HttpClientUtil.setSoTimeout(httpClient, 15000);
  suss = new ConcurrentUpdateSolrServer(
      ((HttpSolrServer) clients.get(0)).getBaseURL(), httpClient, 8,
      2) {
    @Override
    public void handleError(Throwable ex) {
      log.warn("suss error", ex);
    }
  };
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
public FullThrottleStopableIndexingThread(List<SolrServer> clients,
    int startI, boolean doDeletes) {
  super(startI, doDeletes);
  setName("FullThrottleStopableIndexingThread");
  setDaemon(true);
  this.clients = clients;
  HttpClientUtil.setConnectionTimeout(httpClient, 15000);
  HttpClientUtil.setSoTimeout(httpClient, 15000);
  suss = new ConcurrentUpdateSolrServer(
      ((HttpSolrServer) clients.get(0)).getBaseURL(), httpClient, 8,
      2) {
    @Override
    public void handleError(Throwable ex) {
      log.warn("suss error", ex);
    }
  };
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
/**
 * 建造更新用Server
 */
private void buildUpdateSolrServer() {
	this.validConf(); // 必须是已配置的对象
	if (this.isSingle()) { // 必须是单服务器节点
		Type type = this.conf.getType();
		// 标准SolrServer
		if (type.accept(HttpSolrServer.class)) {
			this.httpSolrServer = this.buildHttpSolrServer();
		}
		// 更新用SolrServer
		if (type.accept(ConcurrentUpdateSolrServer.class)) {
			this.updateSolrServer = this.buildConcurrentUpdateSolrServer();
		} else if (type.accept(HttpSolrServer.class)) {
			this.updateSolrServer = this.httpSolrServer;
		}
	}
	this.updateSolrServerBuilt = true;
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public boolean accept(Class<?> solrServerClass) {
	if (solrServerClass == null) {
		return false;
	}
	if (ConcurrentUpdateSolrServer.class.equals(solrServerClass)) {
		return true;
	}
	if (HttpSolrServer.class.equals(solrServerClass)) {
		return true;
	}
	if (this.accept(solrServerClass.getSuperclass())) {
		return true;
	}
	return false;
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Test
@Ignore
public void testFactory() {
	assertNotNull(masterFactory);
	SolrServer solrServer = this.masterFactory.getUpdateSolrServer();
	assertTrue(solrServer instanceof ConcurrentUpdateSolrServer);
	solrServer = this.masterFactory.getUpdateSolrServer(true);
	assertTrue(solrServer.getClass().equals(HttpSolrServer.class));
	solrServer = this.masterFactory.getQuerySolrServer();
	assertTrue(solrServer.getClass().equals(HttpSolrServer.class));
	assertNotNull(slavesFactory);
	solrServer = this.slavesFactory.getUpdateSolrServer();
	assertTrue(solrServer == null);
	solrServer = this.slavesFactory.getUpdateSolrServer(true);
	assertTrue(solrServer == null);
	solrServer = this.slavesFactory.getQuerySolrServer();
	assertTrue(solrServer instanceof LBHttpSolrServer);
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
/**
 * Uses the {@link HttpSolrServer} to index some data to Solr.
 * 
 * @throws Exception in case of I/O or index failure.
 */
@Test
public void concurrentUpdateSolrServer() throws Exception {
	final int bufferSize = 2; // commit each 2 albums
	final int threadsNo = 2; // Use two indexer threads
	
	// 1. Create a new instance of HttpSolrServer 
	// Note that we are simply repeating the same server three times, in order to "simulate" a
	// scenario with three searchers.
	// In a real context we would have three different urls.
	solr = new ConcurrentUpdateSolrServer(SOLR_URI, bufferSize, threadsNo);		
	
	// 2. Create some data
	final List<SolrInputDocument> albums = sampleData();
	
	// 3. Add those data
	solr.add(albums);
	
	// 4. Commit
	solr.commit();
	
	// 5. Verify
	verify();
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public void shutdown() {
    if (server instanceof ConcurrentUpdateSolrServer) {
        ((ConcurrentUpdateSolrServer) server).blockUntilFinished();
    }
    server.shutdown();
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
public void testWaitOptions() throws Exception {
  // SOLR-3903
  final List<Throwable> failures = new ArrayList<>();
  ConcurrentUpdateSolrServer s = new ConcurrentUpdateSolrServer
    (jetty.getBaseUrl().toString() + "/collection1", 2, 2) {
      @Override
      public void handleError(Throwable ex) {
        failures.add(ex);
      }
    };
    
  int docId = 42;
  for (UpdateRequest.ACTION action : EnumSet.allOf(UpdateRequest.ACTION.class)) {
    for (boolean waitSearch : Arrays.asList(true, false)) {
      for (boolean waitFlush : Arrays.asList(true, false)) {
        UpdateRequest updateRequest = new UpdateRequest();
        SolrInputDocument document = new SolrInputDocument();
        document.addField("id", docId++ );
        updateRequest.add(document);
        updateRequest.setAction(action, waitSearch, waitFlush);
        s.request(updateRequest);
      }
    }
  }
  s.commit();
  s.blockUntilFinished();
  s.shutdown();

  if (0 != failures.size()) {
    assertEquals(failures.size() + " Unexpected Exception, starting with...", 
                 null, failures.get(0));
  }
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public SolrServer createNewSolrServer() {
  ConcurrentUpdateSolrServer s = (ConcurrentUpdateSolrServer)super.createNewSolrServer();
  s.setParser(new BinaryResponseParser());
  s.setRequestWriter(new BinaryRequestWriter());
  return s;
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public void commitTransaction() throws SolrServerException, IOException {
  LOGGER.trace("commitTransaction");
  if (batch.size() > 0) {
    loadBatch();
  }
  if (numLoadedDocs > 0) {
    if (server instanceof ConcurrentUpdateSolrServer) {
      ((ConcurrentUpdateSolrServer) server).blockUntilFinished();
    }
  }
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
    if (querySolrServer instanceof HttpSolrServer) {
        HttpSolrServer httpSolrServer = (HttpSolrServer) querySolrServer;
        this.updateSolrServer = new ConcurrentUpdateSolrServer(httpSolrServer.getBaseURL(), httpSolrServer.getHttpClient(), 20, 4);
    } else {
        this.updateSolrServer = querySolrServer;
    }
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
@Override
public SolrServer createAndConfigure(final String role, final Configuration<Map<String, Object>> configuration) {
	return new ConcurrentUpdateSolrServer(
			configuration.getParameter(role + ADDRESS, DEFAULT_ADDRESS), 
			configuration.getParameter(role + QUEUE_SIZE, DEFAULT_QUEUE_SIZE),
			configuration.getParameter(role + THREAD_COUNT, DEFAULT_THREAD_COUNT));
}
 

import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer; //导入依赖的package包/类
public void init() {
	HttpClientBuilder clientBuilder = HttpClientBuilder.create(); 
	httpClient = clientBuilder.build();
	searchServer = new HttpSolrServer(solrUrl, httpClient);
	searchServer.setRequestWriter(new BinaryRequestWriter());
	updateServer = new ConcurrentUpdateSolrServer(solrUrl, 5000, 10);
	updateServer.setRequestWriter(new BinaryRequestWriter());
}