org.elasticsearch.action.ActionRequestBuilder Java Examples

@Override
public MultiSearchRequestBuilder getRequestBuilder(MultiQueryRequest parameter) {

    MultiSearchRequestBuilder multiSearchRequestBuilder = getConnection().getClient()
            .prepareMultiSearch();

    for(Map.Entry<String, ActionRequest> entry : parameter.getRequests()
            .entrySet()) {
        ActionRequest request = entry.getValue();
        Action<ActionRequest> action = analyticsLoader.getAction(request);
        if(null == action) {
            throw FoxtrotExceptions.queryCreationException(request, null);
        }
        ActionRequestBuilder requestBuilder = action.getRequestBuilder(request);
        if(requestBuilder instanceof SearchRequestBuilder) {
            multiSearchRequestBuilder.add((SearchRequestBuilder)requestBuilder);
        }
    }
    return multiSearchRequestBuilder;
}
 

/**
 * Executes the request and fails if the request has not been blocked by a specific {@link ClusterBlock}.
 *
 * @param builder the request builder
 * @param expectedBlock the expected block
 */
public static void assertBlocked(ActionRequestBuilder builder, ClusterBlock expectedBlock) {
    try {
        builder.get();
        fail("Request executed with success but a ClusterBlockException was expected");
    } catch (ClusterBlockException e) {
        assertThat(e.blocks().size(), greaterThan(0));
        assertThat(e.status(), equalTo(RestStatus.FORBIDDEN));

        if (expectedBlock != null) {
            boolean found = false;
            for (ClusterBlock clusterBlock : e.blocks()) {
                if (clusterBlock.id() == expectedBlock.id()) {
                    found = true;
                    break;
                }
            }
            assertThat("Request should have been blocked by [" + expectedBlock + "] instead of " + e.blocks(), found, equalTo(true));
        }
    }
}
 

public long runQuery(String name, int testNum, long expectedHits, ActionRequestBuilder request) {
  long timestamp = System.nanoTime();
  TermsByQueryResponse response = (TermsByQueryResponse) request.execute().actionGet();
  long timeElapsed = System.nanoTime() - timestamp;

  if (response.getFailedShards() > 0) {
    log("Search Failures " + Arrays.toString(response.getShardFailures()));
  }

  long hits = response.getSize();
  if (MAX_TERMS_PER_SHARD == -1 && hits != expectedHits) {
    log("[" + name + "][#" + testNum + "] Hits Mismatch:  expected [" + expectedHits + "], got [" + hits + "]");
  }

  return timeElapsed / 1000000;
}
 

@Override
public <RequestT extends ActionRequest, ResponseT extends ActionResponse,
    RequestBuilderT extends ActionRequestBuilder<RequestT, ResponseT, RequestBuilderT>> void execute(
    Action<RequestT, ResponseT, RequestBuilderT> action, RequestT request, ActionListener<ResponseT> actionListener)
{
  // stub method
}
 

@SuppressWarnings("unchecked")
@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>>
        void doExecute(Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    HttpElasticsearchClient.ActionEntry entry = actionMap.get(action.name());
    if (entry == null) {
        throw new IllegalStateException("no action entry for " + action.name());
    }
    HttpAction<Request, Response> httpAction = entry.httpAction;
    if (httpAction == null) {
        throw new IllegalStateException("failed to find action [" + action + "] to execute");
    }
    HttpInvocationContext<Request, Response> httpInvocationContext = new HttpInvocationContext(httpAction, listener, new LinkedList<>(), request);
    try {
        httpInvocationContext.httpRequest = httpAction.createHttpRequest(this.url, request);
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
    }
    ChannelFuture future = bootstrap.connect(new InetSocketAddress(url.getHost(), url.getPort()));
    future.awaitUninterruptibly();
    if (!future.isSuccess()) {
        bootstrap.releaseExternalResources();
        logger.error("can't connect to {}", url);
    } else {
        Channel channel = future.getChannel();
        httpInvocationContext.setChannel(channel);
        contexts.put(channel, httpInvocationContext);
        channel.getConfig().setConnectTimeoutMillis(settings.getAsInt("http.client.timeout", 5000));
        httpAction.execute(httpInvocationContext, listener);
    }
}
 

@SuppressWarnings("unchecked")
@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void doExecute(Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    ActionEntry entry = actionMap.get(action.name());
    if (entry == null) {
        throw new IllegalStateException("no action entry for " + action.name());
    }
    HttpAction<Request, Response> httpAction = entry.httpAction;
    if (httpAction == null) {
        throw new IllegalStateException("failed to find action [" + action + "] to execute");
    }
    HttpInvocationContext<Request, Response> httpInvocationContext = new HttpInvocationContext(httpAction, listener, new LinkedList<>(), request);
    try {
        httpInvocationContext.httpRequest = httpAction.createHttpRequest(this.url, request);
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
    }
    ChannelFuture future = bootstrap.connect(new InetSocketAddress(url.getHost(), url.getPort()));
    future.awaitUninterruptibly();
    if (!future.isSuccess()) {
        bootstrap.releaseExternalResources();
        logger.error("can't connect to {}", url);
    } else {
        Channel channel = future.getChannel();
        httpInvocationContext.setChannel(channel);
        contextMap.put(channel, httpInvocationContext);
        channel.getConfig().setConnectTimeoutMillis(settings.getAsInt("http.client.timeout", 5000));
        httpAction.execute(httpInvocationContext, listener);
    }
}
 

@Override
public final <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> ActionFuture<Response> execute(
        Action<Request, Response, RequestBuilder> action, Request request) {
    PlainActionFuture<Response> actionFuture = PlainActionFuture.newFuture();
    execute(action, request, actionFuture);
    return actionFuture;
}
 

@Override
public <Request extends TransportRequest,
        Response extends TransportResponse,
        RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void doExecute(
    Action<Request, Response, RequestBuilder> action,
    Request request,
    ActionListener<Response> listener) {

    // Discard the task because the Client interface doesn't use it.
    executeLocally(action, request, listener);
}
 

@Override
public <RequestT extends ActionRequest, ResponseT extends ActionResponse,
    RequestBuilderT extends ActionRequestBuilder<RequestT, ResponseT, RequestBuilderT>> RequestBuilderT prepareExecute(
    Action<RequestT, ResponseT, RequestBuilderT> action)
{
    return null;
}
 

@Override
public <RequestT extends ActionRequest, ResponseT extends ActionResponse,
    RequestBuilderT extends ActionRequestBuilder<RequestT, ResponseT, RequestBuilderT>> ActionFuture<ResponseT> execute(
    Action<RequestT, ResponseT, RequestBuilderT> action, RequestT request)
{
    return null;
}
 

private static long doUpdateRequest(ActionRequestBuilder<?, ? extends UpdateResponse, ?> request)
		throws IOException {
	UpdateResponse response = request.execute().actionGet();
	boolean isUpsert = response.status().equals(RestStatus.CREATED);
	if (isUpsert) {
		throw new IOException("Unexpected upsert: " + request.get().getClass().getName());
	}
	return response.getVersion();
}
 

private static long doIndexRequest(ActionRequestBuilder<?, ? extends IndexResponse, ?> request) throws IOException {
	IndexResponse response = request.execute().actionGet();
	boolean ok = response.status().equals(RestStatus.CREATED);
	if (!ok) {
		throw new IOException("Document not created: " + request.get().getClass().getName());
	}
	return response.getVersion();
}
 

private static void doAcknowledgedRequest(ActionRequestBuilder<?, ? extends AcknowledgedResponse, ?> request)
		throws IOException {
	boolean ok = request.execute().actionGet().isAcknowledged();
	if (!ok) {
		throw new IOException("Request not acknowledged: " + request.get().getClass().getName());
	}
}
 

/**
 * Run the request from a given builder and check that it throws an exception of the right type
 */
public static <E extends Throwable> void assertThrows(ActionRequestBuilder<?, ?, ?> builder, Class<E> exceptionClass) {
    assertThrows(builder.execute(), exceptionClass);
}
 

@Override
public ActionRequestBuilder getRequestBuilder(MultiTimeQueryRequest parameter) {
    return action.getRequestBuilder(multiQueryRequest);
}
 

@Override
public <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
        Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    client.execute(action, request, listener);
}
 

@Override
public <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> ActionFuture<Response> execute(
        Action<Request, Response, RequestBuilder> action, Request request) {
    return client.execute(action, request);
}
 

@Override
public <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
        Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    client.execute(action, request, listener);
}
 

@Override
public <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> ActionFuture<Response> execute(
        Action<Request, Response, RequestBuilder> action, Request request) {
    return client.execute(action, request);
}
 

/**
 * This is the single execution point of *all* clients.
 */
@Override
public final <Request extends TransportRequest, Response extends TransportResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
        Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    doExecute(action, request, listener);
}
 

/**
 * Run the request from a given builder and check that it throws an exception of the right type, with a given {@link RestStatus}
 */
public static <E extends Throwable> void assertThrows(ActionRequestBuilder<?, ?, ?> builder,
        Class<E> exceptionClass, RestStatus status) {
    assertThrows(builder.execute(), exceptionClass, status);
}
 

public static <E extends Throwable> void assertThrows(ActionRequestBuilder<?, ?, ?> builder, RestStatus status) {
    assertThrows(builder.execute(), status);
}
 

public static <E extends Throwable> void assertThrows(ActionRequestBuilder<?, ?, ?> builder, RestStatus status, String extraInfo) {
    assertThrows(builder.execute(), status, extraInfo);
}
 

@Override
protected <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void doExecute(Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
    proxy.execute(action, request, listener);
}
 

@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> ActionFuture<Response> execute(
		Action<Request, Response, RequestBuilder> action, Request request) {
	return wrapped.execute(action, request);
}
 

@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> void execute(
		Action<Request, Response, RequestBuilder> action, Request request, ActionListener<Response> listener) {
	wrapped.execute(action, request, listener);
}
 

@Override
public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> RequestBuilder prepareExecute(
		Action<Request, Response, RequestBuilder> action) {
	return wrapped.prepareExecute(action);
}
 

public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder>> Observable<Optional<Response>> execute(VertxContext<Server> vertxContext, final RequestBuilder actionRequestBuilder, long timeoutMs) {
    return execute(vertxContext.vertx(), actionRequestBuilder, timeoutMs);
}
 

public static String toString(ActionRequestBuilder builder) {
    return builder.request().toString();
}
 

@Override
public ActionRequestBuilder getBuilder() {
    return deleteByQueryRequestBuilder;
}