Java ErrorCode.SERVICE_UNAVAILABLE属性代码示例

@Override
public synchronized void openIndexWriter(SolrCore core) throws IOException {
  log.info("Creating new IndexWriter...");
  synchronized (writerPauseLock) {
    if (closed) {
      throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Already closed");
    }
    
    try {
      indexWriter = createMainIndexWriter(core, "DirectUpdateHandler2");
      log.info("New IndexWriter is ready to be used.");
      // we need to null this so it picks up the new writer next get call
      refCntWriter = null;
    } finally {
      pauseWriter = false;
      writerPauseLock.notifyAll();
    }
  }
}
 

/**
 * Get shard leader properties, with retry if none exist.
 */
public Replica getLeaderRetry(String collection, String shard, int timeout) throws InterruptedException {
  long timeoutAt = System.nanoTime() + TimeUnit.NANOSECONDS.convert(timeout, TimeUnit.MILLISECONDS);
  while (System.nanoTime() < timeoutAt && !closed) {
    if (clusterState != null) {    
      Replica replica = clusterState.getLeader(collection, shard);
      if (replica != null && getClusterState().liveNodesContain(replica.getNodeName())) {
        return replica;
      }
    }
    Thread.sleep(50);
  }
  throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "No registered leader was found after waiting for "
      + timeout + "ms " + ", collection: " + collection + " slice: " + shard);
}
 

@Override
public RefCounted<IndexWriter> getIndexWriter(SolrCore core)
    throws IOException {
  synchronized (writerPauseLock) {
    if (closed) {
      throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "SolrCoreState already closed");
    }
    
    while (pauseWriter) {
      try {
        writerPauseLock.wait(100);
      } catch (InterruptedException e) {}
      
      if (closed) {
        throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Already closed");
      }
    }
    
    if (core == null) {
      // core == null is a signal to just return the current writer, or null
      // if none.
      initRefCntWriter();
      if (refCntWriter == null) return null;
      writerFree = false;
      writerPauseLock.notifyAll();
      if (refCntWriter != null) refCntWriter.incref();
      
      return refCntWriter;
    }
    
    if (indexWriter == null) {
      indexWriter = createMainIndexWriter(core, "DirectUpdateHandler2");
    }
    initRefCntWriter();
    writerFree = false;
    writerPauseLock.notifyAll();
    refCntWriter.incref();
    return refCntWriter;
  }
}
 

@Override
public synchronized void closeIndexWriter(SolrCore core, boolean rollback)
    throws IOException {
  log.info("Closing IndexWriter...");
  String coreName = core.getName();
  synchronized (writerPauseLock) {
    if (closed) {
      throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Already closed");
    }
    
    // we need to wait for the Writer to fall out of use
    // first lets stop it from being lent out
    pauseWriter = true;
    // then lets wait until its out of use
    log.info("Waiting until IndexWriter is unused... core=" + coreName);
    
    while (!writerFree) {
      try {
        writerPauseLock.wait(100);
      } catch (InterruptedException e) {}
      
      if (closed) {
        throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE,
            "SolrCoreState already closed");
      }
    }
    
    if (indexWriter != null) {
      if (!rollback) {
        closeIndexWriter(coreName);
      } else {
        rollbackIndexWriter(coreName);
      }
    }
    
  }
}
 

private void zkCheck() {
  if ((updateCommand.getFlags() & (UpdateCommand.REPLAY | UpdateCommand.PEER_SYNC)) != 0) {
    // for log reply or peer sync, we don't need to be connected to ZK
    return;
  }

  if (!zkController.getZkClient().getConnectionManager().isLikelyExpired()) {
    return;
  }
  
  throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Cannot talk to ZooKeeper - Updates are disabled.");
}
 

/**
 * Creates a new core based on a CoreDescriptor.
 *
 * @param dcore        a core descriptor
 * @param publishState publish core state to the cluster if true
 *
 * @return the newly created core
 */
public SolrCore create(CoreDescriptor dcore, boolean publishState) {

  if (isShutDown) {
    throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Solr has shutdown.");
  }

  try {

    if (zkSys.getZkController() != null) {
      zkSys.getZkController().preRegister(dcore);
    }

    ConfigSet coreConfig = coreConfigService.getConfig(dcore);
    log.info("Creating SolrCore '{}' using configuration from {}", dcore.getName(), coreConfig.getName());
    SolrCore core = new SolrCore(dcore, coreConfig);
    solrCores.addCreated(core);

    // always kick off recovery if we are in non-Cloud mode
    if (!isZooKeeperAware() && core.getUpdateHandler().getUpdateLog() != null) {
      core.getUpdateHandler().getUpdateLog().recoverFromLog();
    }

    registerCore(dcore.getName(), core, publishState);

    return core;

  }
  catch (Exception e) {
    coreInitFailures.put(dcore.getName(), new CoreLoadFailure(dcore, e));
    log.error("Error creating core [{}]: {}", dcore.getName(), e.getMessage(), e);
    throw new SolrException(ErrorCode.SERVER_ERROR, "Unable to create core [" + dcore.getName() + "]", e);
  }

}
 

@Override
public void incRef(Directory directory) {
  synchronized (this) {
    if (closed) {
      throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Already closed");
    }
    CacheValue cacheValue = byDirectoryCache.get(directory);
    if (cacheValue == null) {
      throw new IllegalArgumentException("Unknown directory: " + directory);
    }
    
    cacheValue.refCnt++;
    log.debug("incRef'ed: {}", cacheValue);
  }
}
 

@Override
public synchronized void newIndexWriter(SolrCore core, boolean rollback) throws IOException {
  log.info("Creating new IndexWriter...");
  String coreName = core.getName();
  synchronized (writerPauseLock) {
    if (closed) {
      throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Already closed");
    }
    
    // we need to wait for the Writer to fall out of use
    // first lets stop it from being lent out
    pauseWriter = true;
    // then lets wait until its out of use
    log.info("Waiting until IndexWriter is unused... core=" + coreName);
    
    while (!writerFree) {
      try {
        writerPauseLock.wait(100);
      } catch (InterruptedException e) {}
      
      if (closed) {
        throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "SolrCoreState already closed");
      }
    }

    try {
      if (indexWriter != null) {
        if (!rollback) {
          closeIndexWriter(coreName);
        } else {
          rollbackIndexWriter(coreName);
        }
      }
      indexWriter = createMainIndexWriter(core, "DirectUpdateHandler2");
      log.info("New IndexWriter is ready to be used.");
      // we need to null this so it picks up the new writer next get call
      refCntWriter = null;
    } finally {
      
      pauseWriter = false;
      writerPauseLock.notifyAll();
    }
  }
}
 

private void doDefensiveChecks(DistribPhase phase) {
  boolean isReplayOrPeersync = (updateCommand.getFlags() & (UpdateCommand.REPLAY | UpdateCommand.PEER_SYNC)) != 0;
  if (isReplayOrPeersync) return;

  String from = req.getParams().get(DISTRIB_FROM);
  ClusterState clusterState = zkController.getClusterState();
      
  CloudDescriptor cloudDescriptor = req.getCore().getCoreDescriptor().getCloudDescriptor();
  Slice mySlice = clusterState.getSlice(collection, cloudDescriptor.getShardId());
  boolean localIsLeader = cloudDescriptor.isLeader();
  if (DistribPhase.FROMLEADER == phase && localIsLeader && from != null) { // from will be null on log replay
    String fromShard = req.getParams().get(DISTRIB_FROM_PARENT);
    if (fromShard != null) {
      if (Slice.ACTIVE.equals(mySlice.getState()))  {
        throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE,
            "Request says it is coming from parent shard leader but we are in active state");
      }
      // shard splitting case -- check ranges to see if we are a sub-shard
      Slice fromSlice = zkController.getClusterState().getCollection(collection).getSlice(fromShard);
      DocRouter.Range parentRange = fromSlice.getRange();
      if (parentRange == null) parentRange = new DocRouter.Range(Integer.MIN_VALUE, Integer.MAX_VALUE);
      if (mySlice.getRange() != null && !mySlice.getRange().isSubsetOf(parentRange)) {
        throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE,
            "Request says it is coming from parent shard leader but parent hash range is not superset of my range");
      }
    } else {
      String fromCollection = req.getParams().get(DISTRIB_FROM_COLLECTION); // is it because of a routing rule?
      if (fromCollection == null)  {
        log.error("Request says it is coming from leader, but we are the leader: " + req.getParamString());
        SolrException solrExc = new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Request says it is coming from leader, but we are the leader");
        solrExc.setMetadata("cause", "LeaderChanged");
        throw solrExc;
      }
    }
  }

  if ((isLeader && !localIsLeader) || (isSubShardLeader && !localIsLeader)) {
    log.error("ClusterState says we are the leader, but locally we don't think so");
    throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE,
        "ClusterState says we are the leader (" + zkController.getBaseUrl()
            + "/" + req.getCore().getName() + "), but locally we don't think so. Request came from " + from);
  }
}
 

private void replicate(String nodeName, SolrCore core, ZkNodeProps leaderprops)
    throws SolrServerException, IOException {

  ZkCoreNodeProps leaderCNodeProps = new ZkCoreNodeProps(leaderprops);
  String leaderUrl = leaderCNodeProps.getCoreUrl();
  
  log.info("Attempting to replicate from " + leaderUrl + ". core=" + coreName);
  
  // send commit
  commitOnLeader(leaderUrl);
  
  // use rep handler directly, so we can do this sync rather than async
  SolrRequestHandler handler = core.getRequestHandler(REPLICATION_HANDLER);
  if (handler instanceof LazyRequestHandlerWrapper) {
    handler = ((LazyRequestHandlerWrapper) handler).getWrappedHandler();
  }
  ReplicationHandler replicationHandler = (ReplicationHandler) handler;
  
  if (replicationHandler == null) {
    throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE,
        "Skipping recovery, no " + REPLICATION_HANDLER + " handler found");
  }
  
  ModifiableSolrParams solrParams = new ModifiableSolrParams();
  solrParams.set(ReplicationHandler.MASTER_URL, leaderUrl);
  
  if (isClosed()) return; // we check closed on return
  boolean success = replicationHandler.doFetch(solrParams, false);
  
  if (!success) {
    throw new SolrException(ErrorCode.SERVER_ERROR,
        "Replication for recovery failed.");
  }
  
  // solrcloud_debug
  if (log.isDebugEnabled()) {
    try {
      RefCounted<SolrIndexSearcher> searchHolder = core
          .getNewestSearcher(false);
      SolrIndexSearcher searcher = searchHolder.get();
      Directory dir = core.getDirectoryFactory().get(core.getIndexDir(), DirContext.META_DATA, null);
      try {
        log.debug(core.getCoreDescriptor().getCoreContainer()
            .getZkController().getNodeName()
            + " replicated "
            + searcher.search(new MatchAllDocsQuery(), 1).totalHits
            + " from "
            + leaderUrl
            + " gen:"
            + core.getDeletionPolicy().getLatestCommit().getGeneration()
            + " data:" + core.getDataDir()
            + " index:" + core.getIndexDir()
            + " newIndex:" + core.getNewIndexDir()
            + " files:" + Arrays.asList(dir.listAll()));
      } finally {
        core.getDirectoryFactory().release(dir);
        searchHolder.decref();
      }
    } catch (Exception e) {
      throw new SolrException(ErrorCode.SERVER_ERROR, null, e);
    }
  }

}