Java CoreAdminAction类代码示例

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
@Override
public void swapActiveCores() throws ServiceException {
    if (SolrContext.isSingleCoreMode()) {
        LOG.debug("In single core mode. There are no cores to swap.");
    } else {
        LOG.debug("Swapping active cores");

        CoreAdminRequest car = new CoreAdminRequest();
        car.setCoreName(SolrContext.PRIMARY);
        car.setOtherCoreName(SolrContext.REINDEX);
        car.setAction(CoreAdminAction.SWAP);

        try {
            SolrContext.getAdminServer().request(car);
        } catch (Exception e) {
            LOG.error(e);
            throw new ServiceException("Unable to swap cores", e);
        }
    }
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void invokeOverseerOp(String electionNode, String op) {
  ModifiableSolrParams params = new ModifiableSolrParams();
  ShardHandler shardHandler = shardHandlerFactory.getShardHandler();
  params.set(CoreAdminParams.ACTION, CoreAdminAction.OVERSEEROP.toString());
  params.set("op", op);
  params.set("qt", adminPath);
  params.set("electionNode", electionNode);
  ShardRequest sreq = new ShardRequest();
  sreq.purpose = 1;
  String replica = zkStateReader.getBaseUrlForNodeName(LeaderElector.getNodeName(electionNode));
  sreq.shards = new String[]{replica};
  sreq.actualShards = sreq.shards;
  sreq.params = params;
  shardHandler.submit(sreq, replica, sreq.params);
  shardHandler.takeCompletedOrError();
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void requestRecovery(final ZkNodeProps leaderProps, final String baseUrl, final String coreName) throws SolrServerException, IOException {
  // TODO: do this in background threads
  Thread thread = new Thread() {
    {
      setDaemon(true);
    }
    @Override
    public void run() {
      RequestRecovery recoverRequestCmd = new RequestRecovery();
      recoverRequestCmd.setAction(CoreAdminAction.REQUESTRECOVERY);
      recoverRequestCmd.setCoreName(coreName);
      
      HttpSolrServer server = new HttpSolrServer(baseUrl);
      server.setConnectionTimeout(45000);
      server.setSoTimeout(45000);
      try {
        server.request(recoverRequestCmd);
      } catch (Throwable t) {
        SolrException.log(log, ZkCoreNodeProps.getCoreUrl(leaderProps) + ": Could not tell a replica to recover", t);
      }
    }
  };
  recoveryCmdExecutor.execute(thread);
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
public static CoreAdminResponse reloadCore( String name, SolrServer server ) throws SolrServerException, IOException
{
  CoreAdminRequest req = new CoreAdminRequest();
  req.setCoreName( name );
  req.setAction( CoreAdminAction.RELOAD );
  return req.process( server );
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
public static CoreAdminResponse renameCore(String coreName, String newName, SolrServer server ) throws SolrServerException, IOException
{
  CoreAdminRequest req = new CoreAdminRequest();
  req.setCoreName(coreName);
  req.setOtherCoreName(newName);
  req.setAction( CoreAdminAction.RENAME );
  return req.process( server );
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
public static CoreAdminResponse getStatus( String name, SolrServer server ) throws SolrServerException, IOException
{
  CoreAdminRequest req = new CoreAdminRequest();
  req.setCoreName( name );
  req.setAction( CoreAdminAction.STATUS );
  return req.process( server );
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
  // Make sure the cores is enabled
  CoreContainer cores = getCoreContainer();
  if (cores == null) {
    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
            "Core container instance missing");
  }
  //boolean doPersist = false;
  String taskId = req.getParams().get("async");
  TaskObject taskObject = new TaskObject(taskId);

  if(taskId != null) {
    // Put the tasks into the maps for tracking
    if (getMap(RUNNING).containsKey(taskId) || getMap(COMPLETED).containsKey(taskId) || getMap(FAILED).containsKey(taskId)) {
      throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
          "Duplicate request with the same requestid found.");
    }

    addTask(RUNNING, taskObject);
  }

  // Pick the action
  SolrParams params = req.getParams();
  CoreAdminAction action = CoreAdminAction.STATUS;
  String a = params.get(CoreAdminParams.ACTION);
  if (a != null) {
    action = CoreAdminAction.get(a);
    if (action == null) {
      this.handleCustomAction(req, rsp);
    }
  }

  if (taskId == null) {
    handleRequestInternal(req, rsp, action);
  } else {
    ParallelCoreAdminHandlerThread parallelHandlerThread = new ParallelCoreAdminHandlerThread(req, rsp, action, taskObject);
    parallelExecutor.execute(parallelHandlerThread);
  }
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
public ParallelCoreAdminHandlerThread (SolrQueryRequest req, SolrQueryResponse rsp,
                                       CoreAdminAction action, TaskObject taskObject){
  this.req = req;
  this.rsp = rsp;
  this.action = action;
  this.taskObject = taskObject;
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void requestRecovery(final ZkNodeProps leaderProps, final String baseUrl, final String coreName) throws SolrServerException, IOException {
  Thread thread = new Thread() {
    {
      setDaemon(true);
    }
    @Override
    public void run() {
      RequestRecovery recoverRequestCmd = new RequestRecovery();
      recoverRequestCmd.setAction(CoreAdminAction.REQUESTRECOVERY);
      recoverRequestCmd.setCoreName(coreName);
      
      HttpSolrServer server = new HttpSolrServer(baseUrl, client);
      try {
        server.setConnectionTimeout(30000);
        server.setSoTimeout(120000);
        server.request(recoverRequestCmd);
      } catch (Throwable t) {
        SolrException.log(log, ZkCoreNodeProps.getCoreUrl(leaderProps) + ": Could not tell a replica to recover", t);
        if (t instanceof Error) {
          throw (Error) t;
        }
      } finally {
        server.shutdown();
      }
    }
  };
  updateExecutor.execute(thread);
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
/**
 * Get list of cores from the remote Solr server.
 * 
 * @return Map of cores attributes keyed by core name.
 * @throws SophieException
 *             If the list of cores cannot be fetched.
 */
@SuppressWarnings("unchecked")
public static Map<String, NamedList<Object>> getRemoteCores() throws SophieException {
    CoreAdminRequest request = new CoreAdminRequest();
    request.setAction(CoreAdminAction.STATUS);
    try {
        CoreAdminResponse response = request.process(Sophie.client);
        return response.getCoreStatus().asMap(-1);
    } catch (SolrServerException | IOException | SolrException e) {
        throw new SophieException("Unable to fetch list of Solr cores", e);
    }
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
@Test
public void testReloadCore() throws Exception {
  SolrInputDocument doc = new SolrInputDocument();
  doc.addField("uri", "/doc/1");
  doc.addField(TITLE_FIELD, TITLE);
  doc.addField(TEXT_FIELD, TEXT);
  solr.add(doc);
  solr.commit(false, true, true);

  CoreAdminRequest reload = new CoreAdminRequest();
  reload.setAction(CoreAdminAction.RELOAD);
  reload.setCoreName("collection1");
  reload.process(solr);
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private boolean checkIndexExists(IndexConfiguration indexConfiguration) {
    CoreAdminResponse cores = null;
    
    try {
        CoreAdminRequest request = new CoreAdminRequest();
        request.setAction(CoreAdminAction.STATUS);
        cores = request.process(solrServer);
    } catch (SolrServerException | IOException e) {
        throw new SolrConfigurationException("Unable to check solr indexes status", e);
    }
    
    NamedList<Object> indexStatus = cores.getCoreStatus(indexConfiguration.getName());
    
    return indexStatus != null;
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void invokeOverseerOp(String nodeName, String op) {
  ModifiableSolrParams params = new ModifiableSolrParams();
  params.set(CoreAdminParams.ACTION, CoreAdminAction.OVERSEEROP.toString());
  params.set("op", op);
  params.set("qt", adminPath);
  ShardRequest sreq = new ShardRequest();
  sreq.purpose = 1;
  String replica = zkStateReader.getBaseUrlForNodeName(nodeName);
  sreq.shards = new String[]{replica};
  sreq.actualShards = sreq.shards;
  sreq.params = params;
  shardHandler.submit(sreq, replica, sreq.params);
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void verifyQueryAccess(CoreAdminAction action, boolean checkCollection) throws Exception {
  CoreContainer cc = getCleanCoreContainer(action);
  CoreAdminHandler handler = new SecureCoreAdminHandler(cc);
  verifyAuthorized(handler, getCoreAdminRequest("collection1", "junit", action));
  verifyAuthorized(handler, getCoreAdminRequest("queryCollection", "junit", action));
  if (!checkCollection) {
    verifyAuthorized(handler, getCoreAdminRequest("bogusCollection", "junit", action));
    verifyAuthorized(handler, getCoreAdminRequest("updateCollection", "junit", action));
  } else {
    verifyUnauthorized(handler, getCoreAdminRequest("bogusCollection", "junit", action), "bogusCollection", "junit");
    verifyUnauthorized(handler, getCoreAdminRequest("updateCollection", "junit", action), "updateCollection", "junit");
  }
}
 

import org.apache.solr.common.params.CoreAdminParams.CoreAdminAction; //导入依赖的package包/类
private void verifyUpdateAccess(CoreAdminAction action, boolean checkCollection) throws Exception {
  CoreContainer cc = getCleanCoreContainer(action);
  CoreAdminHandler handler = new SecureCoreAdminHandler(cc);
  verifyAuthorized(handler, getCoreAdminRequest("collection1", "junit", action));
  verifyAuthorized(handler, getCoreAdminRequest("updateCollection", "junit", action));
  verifyUnauthorized(handler, getCoreAdminRequest("bogusCollection", "bogusUser", action), "bogusCollection", "bogusUser", true);
  if (checkCollection) {
    verifyUnauthorized(handler, getCoreAdminRequest("queryCollection", "junit", action), "queryCollection", "junit");
  }
}