Java Code Examples for org.apache.solr.client.solrj.SolrRequest#METHOD

@Override
public void execute(SimScenario scenario) throws Exception {
  String path = params.get("path", "/");
  SolrRequest.METHOD m = SolrRequest.METHOD.valueOf(params.get("httpMethod", "GET"));
  params.remove("httpMethod");
  String streamBody = params.get("stream.body");
  params.remove("stream.body");
  GenericSolrRequest req = new GenericSolrRequest(m, path, params);
  if (streamBody != null) {
    req.setContentWriter(new RequestWriter.StringPayloadContentWriter(streamBody, "application/json"));
  }
  SolrResponse rsp = scenario.cluster.request(req);
  @SuppressWarnings({"unchecked"})
  List<SolrResponse> responses = (List<SolrResponse>) scenario.context.computeIfAbsent(RESPONSES_CTX_PROP, Utils.NEW_ARRAYLIST_FUN);
  responses.add(rsp);
}
 

static ZkNodeProps compareOutput(final ApiBag apiBag, final String path, final SolrRequest.METHOD method,
                          final String payload, final CoreContainer cc, String expectedOutputMapJson) throws Exception {
  Pair<SolrQueryRequest, SolrQueryResponse> ctx = makeCall(apiBag, path, method, payload, cc);
  ZkNodeProps output = (ZkNodeProps) ctx.second().getValues().get(ZkNodeProps.class.getName());
  @SuppressWarnings({"rawtypes"})
  Map expected = (Map) fromJSONString(expectedOutputMapJson);
  assertMapEqual(expected, output);
  return output;
}
 

private SolrQueryResponse invoke(PluginBag<SolrRequestHandler> reqHandlers, String path,
                                 String fullPath, SolrRequest.METHOD method,
                                 CoreContainer mockCC) {
  HashMap<String, String> parts = new HashMap<>();
  boolean containerHandlerLookup = mockCC.getRequestHandlers() == reqHandlers;
  path = path == null ? fullPath : path;
  Api api = null;
  if (containerHandlerLookup) {
    api = V2HttpCall.getApiInfo(reqHandlers, path, "GET", fullPath, parts);
  } else {
    api = V2HttpCall.getApiInfo(mockCC.getRequestHandlers(), fullPath, "GET", fullPath, parts);
    if (api == null) api = new CompositeApi(null);
    if (api instanceof CompositeApi) {
      CompositeApi compositeApi = (CompositeApi) api;
      api = V2HttpCall.getApiInfo(reqHandlers, path, "GET", fullPath, parts);
      compositeApi.add(api);
      api = compositeApi;
    }
  }

  SolrQueryResponse rsp = new SolrQueryResponse();
  LocalSolrQueryRequest req = new LocalSolrQueryRequest(null, new MapSolrParams(new HashMap<>())) {
    @Override
    public List<CommandOperation> getCommands(boolean validateInput) {
      return Collections.emptyList();
    }
  };

  api.call(req, rsp);
  return rsp;

}
 

@SuppressWarnings({"rawtypes"})
public static SolrRequest create(SolrRequest.METHOD m, String subPath, String message, SolrParams params) {
  final boolean useV1 = LuceneTestCase.random().nextBoolean();
  String path = useV1 ? "/admin/autoscaling" : "/cluster/autoscaling";
  if (null != subPath) {
    assert subPath.startsWith("/");
    path += subPath;
  }
  return useV1
      ? new AutoScalingRequest(m, path, message).withParams(params)
      : new V2Request.Builder(path).withMethod(m).withParams(params).withPayload(message).build();

}
 

public static Pair<SolrQueryRequest, SolrQueryResponse> makeCall(final ApiBag apiBag, String path,
                                                                 final SolrRequest.METHOD method,
                                                                 final String payload, final CoreContainer cc) throws Exception {
  SolrParams queryParams = new MultiMapSolrParams(Collections.emptyMap());
  if (path.indexOf('?') > 0) {
    String queryStr = path.substring(path.indexOf('?') + 1);
    path = path.substring(0, path.indexOf('?'));
    queryParams = SolrRequestParsers.parseQueryString(queryStr);
  }
  final HashMap<String, String> parts = new HashMap<>();
  Api api = apiBag.lookup(path, method.toString(), parts);
  if (api == null) throw new RuntimeException("No handler at path :" + path);
  SolrQueryResponse rsp = new SolrQueryResponse();
  LocalSolrQueryRequest req = new LocalSolrQueryRequest(null, queryParams) {
    @Override
    public List<CommandOperation> getCommands(boolean validateInput) {
      if (payload == null) return Collections.emptyList();
      return ApiBag.getCommandOperations(new ContentStreamBase.StringStream(payload), api.getCommandSchema(), true);
    }

    @Override
    public Map<String, String> getPathTemplateValues() {
      return parts;
    }

    @Override
    public String getHttpMethod() {
      return method.toString();
    }
  };
  try {
    api.call(req, rsp);
  } catch (ApiBag.ExceptionWithErrObject e) {
    throw new RuntimeException(e.getMessage() + Utils.toJSONString(e.getErrs()), e);

  }
  return new Pair<>(req, rsp);
}
 

public synchronized Api unregister(SolrRequest.METHOD method, String path) {
  List<String> l = PathTrie.getPathSegments(path);
  List<String> introspectPath = new ArrayList<>(l);
  introspectPath.add("_introspect");
  getRegistry(method.toString()).remove(introspectPath);
  return getRegistry(method.toString()).remove(l);
}
 

@SuppressWarnings({"unchecked"})
Meta(EndPoint endPoint, SolrRequest.METHOD method, CoreAdminAction action, String commandName,
     @SuppressWarnings({"rawtypes"})Map paramstoAttr) {
  this.commandName = commandName;
  this.endPoint = endPoint;
  this.method = method;
  this.paramstoAttr = paramstoAttr == null ? Collections.EMPTY_MAP : Collections.unmodifiableMap(paramstoAttr);
  this.action = action;
}
 

@Override
public byte[] httpRequest(String url, SolrRequest.METHOD method, Map<String, String> headers, String payload, int timeout, boolean followRedirects) throws IOException {
  return delegate.httpRequest(url, method, headers, payload, timeout, followRedirects);
}
 

/**
 * HTTP requests are not supported by this implementation.
 */
@Override
public byte[] httpRequest(String url, SolrRequest.METHOD method, Map<String, String> headers, String payload, int timeout, boolean followRedirects) throws IOException {
  throw new UnsupportedOperationException("general HTTP requests are not supported yet");
}
 

static void assertErrorContains(final ApiBag apiBag, final String path, final SolrRequest.METHOD method,
    final String payload, final CoreContainer cc, String expectedErrorMsg) throws Exception {
  RuntimeException e = expectThrows(RuntimeException.class, () -> makeCall(apiBag, path, method, payload, cc));
  assertTrue("Expected exception with error message '" + expectedErrorMsg + "' but got: " + e.getMessage(),
      e.getMessage().contains(expectedErrorMsg));
}
 

@Override
public SolrRequest.METHOD getHttpMethod() {
  return method;
}
 

ConfigSetMeta(ConfigSetEndPoint endPoint, SolrRequest.METHOD method, String cmdName, ConfigSetAction action) {
  this.cmdName = cmdName;
  this.endPoint = endPoint;
  this.method = method;
  this.action = action;
}
 

@Override
public SolrRequest.METHOD getHttpMethod() {
  return method;
}
 

Meta(EndPoint endPoint, SolrRequest.METHOD method, CollectionAction action,
     String commandName,
     @SuppressWarnings({"rawtypes"})Map paramsToAttrs) {
  this(endPoint, method, action, commandName, paramsToAttrs, Collections.emptyMap());
}
 

public SolrRequest.METHOD getMethod() {
  return method;
}
 

@Override
public SolrRequest.METHOD getHttpMethod() {
  return method;
}
 

/**
 * the http method supported by this command
 */
SolrRequest.METHOD getHttpMethod();
 

/**
 * Creates a request using a randomized root path (V1 vs V2)
 *
 * @param m HTTP Method to use
 * @param subPath optional sub-path under <code>"$ROOT/autoscaling"</code>. may be null, 
 *        otherwise must start with "/"
 * @param message JSON payload, may be null
 */
@SuppressWarnings({"rawtypes"})
public static SolrRequest create(SolrRequest.METHOD m, String subPath, String message) {
  return create(m,subPath,message,null);

}
 

public SolrRequest.METHOD getMethod(){
  return api.getEndPoint().method()[0];

}
 

byte[] httpRequest(String url, SolrRequest.METHOD method, Map<String, String> headers, String payload, int timeout, boolean followRedirects) throws IOException;