Java ErrorCode.BAD_REQUEST属性代码示例

/**
  * @param existsRequested facet.exists=true is passed for the given field
  * */
static FacetMethod selectFacetMethod(String fieldName, 
                                     SchemaField field, FacetMethod method, Integer mincount,
                                     boolean existsRequested) {
  if (existsRequested) {
    checkMincountOnExists(fieldName, mincount);
    if (method == null) {
      method = FacetMethod.ENUM;
    }
  }
  final FacetMethod facetMethod = selectFacetMethod(field, method, mincount);
  
  if (existsRequested && facetMethod!=FacetMethod.ENUM) {
    throw new SolrException (ErrorCode.BAD_REQUEST, 
        FacetParams.FACET_EXISTS + "=true is requested, but "+
        FacetParams.FACET_METHOD+"="+FacetParams.FACET_METHOD_enum+ " can't be used with "+fieldName
    );
  }
  return facetMethod;
}
 

private Set<String> getCollectionList(ClusterState clusterState,
    String collection) {
  // Extract each comma separated collection name and store in a List.
  List<String> rawCollectionsList = StrUtils.splitSmart(collection, ",", true);
  Set<String> collectionsList = new HashSet<>();
  // validate collections
  for (String collectionName : rawCollectionsList) {
    if (!clusterState.getCollections().contains(collectionName)) {
      Aliases aliases = zkStateReader.getAliases();
      String alias = aliases.getCollectionAlias(collectionName);
      if (alias != null) {
        List<String> aliasList = StrUtils.splitSmart(alias, ",", true); 
        collectionsList.addAll(aliasList);
        continue;
      }
      
      throw new SolrException(ErrorCode.BAD_REQUEST, "Collection not found: " + collectionName);
    }
    
    collectionsList.add(collectionName);
  }
  return collectionsList;
}
 

/**
 * Get collection status from cluster state.
 * Can return collection status by given shard name.
 *
 *
 * @param clusterState cloud state map parsed from JSON-serialized {@link ClusterState}
 * @param name  collection name
 * @param shardStr comma separated shard names
 * @return map of collection properties
 */
private Map<String, Object> getCollectionStatus(Map<String, Object> clusterState, String name, String shardStr) {
  Map<String, Object> docCollection = (Map<String, Object>) clusterState.get(name);
  if (docCollection == null)  {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Collection: " + name + " not found");
  }
  if (shardStr == null) {
    return docCollection;
  } else {
    Map<String, Object> shards = (Map<String, Object>) docCollection.get("shards");
    Map<String, Object>  selected = new HashMap<>();
    List<String> selectedShards = Arrays.asList(shardStr.split(","));
    for (String selectedShard : selectedShards) {
      if (!shards.containsKey(selectedShard)) {
        throw new SolrException(ErrorCode.BAD_REQUEST, "Collection: " + name + " shard: " + selectedShard + " not found");
      }
      selected.put(selectedShard, shards.get(selectedShard));
      docCollection.put("shards", selected);
    }
    return docCollection;
  }
}
 

private void handleRequestBufferUpdatesAction(SolrQueryRequest req, SolrQueryResponse rsp) {
  SolrParams params = req.getParams();
  String cname = params.get(CoreAdminParams.NAME, "");
  log.info("Starting to buffer updates on core:" + cname);

  try (SolrCore core = coreContainer.getCore(cname)) {
    if (core == null)
      throw new SolrException(ErrorCode.BAD_REQUEST, "Core [" + cname + "] does not exist");
    UpdateLog updateLog = core.getUpdateHandler().getUpdateLog();
    if (updateLog.getState() != UpdateLog.State.ACTIVE)  {
      throw new SolrException(ErrorCode.SERVER_ERROR, "Core " + cname + " not in active state");
    }
    updateLog.bufferUpdates();
    rsp.add("core", cname);
    rsp.add("status", "BUFFERING");
  } catch (Throwable e) {
    if (e instanceof SolrException)
      throw (SolrException)e;
    else
      throw new SolrException(ErrorCode.SERVER_ERROR, "Could not start buffering updates", e);
  } finally {
    if (req != null) req.close();
  }
}
 

public static Object getObjectFrom( String val, String type )
{
  if( type != null ) {
    try {
      if( "int".equals( type ) ) return Integer.valueOf( val );
      if( "double".equals( type ) ) return Double.valueOf( val );
      if( "float".equals( type ) ) return Float.valueOf( val );
      if( "date".equals( type ) ) return DateUtil.parseDate(val);
    }
    catch( Exception ex ) {
      throw new SolrException( ErrorCode.BAD_REQUEST,
          "Unable to parse "+type+"="+val, ex );
    }
  }
  return val;
}
 

@Override
protected boolean updateInitArgs(NamedList<?> updatedArgs) {
  if (updatedArgs == null || updatedArgs.size() == 0) {
    return false;
  }
  boolean currentIgnoreCase = getIgnoreCase(managedInitArgs);
  boolean updatedIgnoreCase = getIgnoreCase(updatedArgs);
  if (currentIgnoreCase == true && updatedIgnoreCase == false) {
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "Changing a managed word set's ignoreCase arg from true to false is not permitted.");
  } else if (currentIgnoreCase == false && updatedIgnoreCase == true) {
    // rebuild the word set on policy change from case-sensitive to case-insensitive
    SortedSet<String> updatedWords = new TreeSet<>();
    for (String word : managedWords) {
      updatedWords.add(word.toLowerCase(Locale.ROOT));
    }
    managedWords = updatedWords;
  }
  // otherwise currentIgnoreCase == updatedIgnoreCase: nothing to do
  return super.updateInitArgs(updatedArgs);
}
 

private String getUrlFromZk(String collection) {
  ClusterState clusterState = getCommonCloudSolrServer().getZkStateReader().getClusterState();
  Map<String,Slice> slices = clusterState.getSlicesMap(collection);
  
  if (slices == null) {
    throw new SolrException(ErrorCode.BAD_REQUEST, "Could not find collection:" + collection);
  }
  
  for (Map.Entry<String,Slice> entry : slices.entrySet()) {
    Slice slice = entry.getValue();
    Map<String,Replica> shards = slice.getReplicasMap();
    Set<Map.Entry<String,Replica>> shardEntries = shards.entrySet();
    for (Map.Entry<String,Replica> shardEntry : shardEntries) {
      final ZkNodeProps node = shardEntry.getValue();
      if (clusterState.liveNodesContain(node.getStr(ZkStateReader.NODE_NAME_PROP))) {
        return ZkCoreNodeProps.getCoreUrl(node.getStr(ZkStateReader.BASE_URL_PROP), collection); //new ZkCoreNodeProps(node).getCoreUrl();
      }
    }
  }
  
  throw new RuntimeException("Could not find a live node for collection:" + collection);
}
 

public static void checkMincountOnExists(String fieldName, int mincount) {
  if (mincount > 1) {
      throw new SolrException (ErrorCode.BAD_REQUEST,
          FacetParams.FACET_MINCOUNT + "="+mincount+" exceed 1 that's not supported with " + 
              FacetParams.FACET_EXISTS + "=true for " + fieldName
      );
    }
}
 

/**
 * Given a url-encoded query string (UTF-8), map it into the given map
 * @param queryString as given from URL
 * @param map place all parameters in this map
 */
static void parseQueryString(final String queryString, final Map<String,String[]> map) {
  if (queryString != null && queryString.length() > 0) {
    try {
      final int len = queryString.length();
      // this input stream emulates to get the raw bytes from the URL as passed to servlet container, it disallows any byte > 127 and enforces to %-escape them:
      final InputStream in = new InputStream() {
        int pos = 0;
        @Override
        public int read() {
          if (pos < len) {
            final char ch = queryString.charAt(pos);
            if (ch > 127) {
              throw new SolrException(ErrorCode.BAD_REQUEST, "URLDecoder: The query string contains a not-%-escaped byte > 127 at position " + pos);
            }
            pos++;
            return ch;
          } else {
            return -1;
          }
        }
      };
      parseFormDataContent(in, Long.MAX_VALUE, StandardCharsets.UTF_8, map, true);
    } catch (IOException ioe) {
      throw new SolrException(ErrorCode.BAD_REQUEST, ioe);
    }
  }
}
 

private static String decodeChars(byte[] bytes, long position, CharsetDecoder charsetDecoder) {
  try {
    return charsetDecoder.decode(ByteBuffer.wrap(bytes)).toString();
  } catch (CharacterCodingException cce) {
    throw new SolrException(ErrorCode.BAD_REQUEST,
      "URLDecoder: Invalid character encoding detected after position " + position +
      " of query string / form data (while parsing as " + charsetDecoder.charset().name() + ")"
    );
  }
}
 

private static int digit16(int b) {
  if (b == -1) {
    throw new SolrException(ErrorCode.BAD_REQUEST, "URLDecoder: Incomplete trailing escape (%) pattern");
  }
  if (b >= '0' && b <= '9') {
    return b - '0';
  }
  if (b >= 'A' && b <= 'F') {
    return b - ('A' - 10);
  }
  if (b >= 'a' && b <= 'f') {
    return b - ('a' - 10);
  }
  throw new SolrException(ErrorCode.BAD_REQUEST, "URLDecoder: Invalid digit (" + ((char) b) + ") in escape (%) pattern");
}
 

public static Style getStyle( String str )
{
  try {
    return Style.valueOf( str );
  }
  catch( Exception ex ) {
    throw new SolrException( ErrorCode.BAD_REQUEST,
        "Unknown Explain Style: "+str );
  }
}
 

private void doSnapShoot(SolrParams params, SolrQueryResponse rsp,
    SolrQueryRequest req) {
  try {
    int numberToKeep = params.getInt(NUMBER_BACKUPS_TO_KEEP_REQUEST_PARAM, 0);
    if (numberToKeep > 0 && numberBackupsToKeep > 0) {
      throw new SolrException(ErrorCode.BAD_REQUEST, "Cannot use "
          + NUMBER_BACKUPS_TO_KEEP_REQUEST_PARAM + " if "
          + NUMBER_BACKUPS_TO_KEEP_INIT_PARAM
          + " was specified in the configuration.");
    }
    numberToKeep = Math.max(numberToKeep, numberBackupsToKeep);
    if (numberToKeep < 1) {
      numberToKeep = Integer.MAX_VALUE;
    }
    
    IndexDeletionPolicyWrapper delPolicy = core.getDeletionPolicy();
    IndexCommit indexCommit = delPolicy.getLatestCommit();
    
    if (indexCommit == null) {
      indexCommit = req.getSearcher().getIndexReader().getIndexCommit();
    }
    
    // small race here before the commit point is saved
    SnapShooter snapShooter = new SnapShooter(core, params.get("location"), params.get("name"));
    snapShooter.validateCreateSnapshot();
    snapShooter.createSnapAsync(indexCommit, numberToKeep, this);
    
  } catch (Exception e) {
    LOG.warn("Exception during creating a snapshot", e);
    rsp.add("exception", e);
  }
}
 

private void handleCreateAction(SolrQueryRequest req,
    SolrQueryResponse rsp) throws InterruptedException, KeeperException {
  log.info("Creating Collection : " + req.getParamString());
  String name = req.getParams().required().get("name");
  if (name == null) {
    log.error("Collection name is required to create a new collection");
    throw new SolrException(ErrorCode.BAD_REQUEST,
        "Collection name is required to create a new collection");
  }
  
  Map<String,Object> props = ZkNodeProps.makeMap(
      Overseer.QUEUE_OPERATION,
      OverseerCollectionProcessor.CREATECOLLECTION,
      "fromApi","true");
  copyIfNotNull(req.getParams(), props,
       "name",
       ZkStateReader.REPLICATION_FACTOR,
       COLL_CONF,
       NUM_SLICES,
       MAX_SHARDS_PER_NODE,
       CREATE_NODE_SET,
       SHARDS_PROP,
       ASYNC,
       AUTO_ADD_REPLICAS,
      "router.");

  copyPropertiesIfNotNull(req.getParams(), props);

  ZkNodeProps m = new ZkNodeProps(props);
  handleResponse(OverseerCollectionProcessor.CREATECOLLECTION, m, rsp);
}
 

private void checkRequired(ZkNodeProps message, String... props) {
  for (String prop : props) {
    if(message.get(prop) == null){
      throw new SolrException(ErrorCode.BAD_REQUEST, StrUtils.join(Arrays.asList(props),',') +" are required params" );
    }
  }

}