@Override protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException { LicenseInfoRequest licenseInfoRequest = new LicenseInfoRequest(); return channel -> client.executeLocally(LicenseInfoAction.INSTANCE, licenseInfoRequest, new NodesResponseRestListener<>(channel)); }
public static String sqlToEsQuery(String sql) throws Exception { Map actions = new HashMap(); Settings settings = Settings.builder().build(); // Client client = new NodeClient(settings, null, null, actions); // Settings.builder() // .put(ThreadContext.PREFIX + ".key1", "val1") // .put(ThreadContext.PREFIX + ".key2", "val 2") // .build(); ThreadPool threadPool = new ThreadPool(settings); Client client = new NodeClient(settings, threadPool); SearchDao searchDao = new org.nlpcn.es4sql.SearchDao(client); try { return searchDao.explain(sql).explain().explain(); } catch (Exception e) { throw e; } }
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link ActionListener}. Prefer this * method if you don't need access to the task when listening for the response. This is the method used to implement the {@link Client} * interface. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, ActionListener<Response> listener) { return transportAction(action).execute(request, listener); }
@Override public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) { return channel -> client.admin().cluster().listTasks(generateListTasksRequest(request), new RestResponseListener<ListTasksResponse>(channel) { @Override public RestResponse buildResponse(ListTasksResponse listTasksResponse) throws Exception { return RestTable.buildResponse(buildTable(request, listTasksResponse), channel); } }); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { return channel -> client.execute(MainAction.INSTANCE, new MainRequest(), new RestBuilderListener<MainResponse>(channel) { @Override public RestResponse buildResponse(MainResponse mainResponse, XContentBuilder builder) throws Exception { return convertMainResponse(mainResponse, request, builder); } }); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { MultiSearchRequest multiSearchRequest = parseRequest(request, allowExplicitIndex); return channel -> client.multiSearch(multiSearchRequest, new RestToXContentListener<>(channel)); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { TermVectorsRequest termVectorsRequest = new TermVectorsRequest(request.param("index"), request.param("type"), request.param("id")); if (request.hasContentOrSourceParam()) { try (XContentParser parser = request.contentOrSourceParamParser()) { TermVectorsRequest.parseRequest(termVectorsRequest, parser); } } readURIParameters(termVectorsRequest, request); return channel -> client.termVectors(termVectorsRequest, new RestToXContentListener<>(channel)); }
@Override public Client getRemoteClusterClient(String clusterAlias) { return remoteClusterService.getRemoteClusterClient(threadPool(), clusterAlias); } }
@Override public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) { ClusterHealthRequest clusterHealthRequest = new ClusterHealthRequest(); return channel -> client.admin().cluster().health(clusterHealthRequest, new RestResponseListener<ClusterHealthResponse>(channel) { @Override public RestResponse buildResponse(final ClusterHealthResponse health) throws Exception { return RestTable.buildResponse(buildTable(health, request), channel); } }); }
@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) { // Discard the task because the Client interface doesn't use it. executeLocally(action, request, listener); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { return channel -> client.execute(RemoteInfoAction.INSTANCE, new RemoteInfoRequest(), new RestBuilderListener<RemoteInfoResponse>(channel) { @Override public RestResponse buildResponse(RemoteInfoResponse response, XContentBuilder builder) throws Exception { response.toXContent(builder, request); return new BytesRestResponse(RestStatus.OK, builder); } }); } @Override
/** * Execute an {@link Action} locally, returning that {@link Task} used to track it, and linking an {@link TaskListener}. Prefer this * method if you need access to the task when listening for the response. */ public < Request extends ActionRequest, Response extends ActionResponse > Task executeLocally(GenericAction<Request, Response> action, Request request, TaskListener<Response> listener) { return transportAction(action).execute(request, listener); }
/** * Retrieve the latest indices stats, calling the listener when complete * @return a latch that can be used to wait for the indices stats to complete if desired */ protected CountDownLatch updateIndicesStats(final ActionListener<IndicesStatsResponse> listener) { final CountDownLatch latch = new CountDownLatch(1); final IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest(); indicesStatsRequest.clear(); indicesStatsRequest.store(true); client.admin().indices().stats(indicesStatsRequest, new LatchedActionListener<>(listener, latch)); return latch; }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { final ListTasksRequest listTasksRequest = generateListTasksRequest(request); final String groupBy = request.param("group_by", "nodes"); return channel -> client.admin().cluster().listTasks(listTasksRequest, listTasksResponseListener(nodesInCluster, groupBy, channel)); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, NodeClient client) throws IOException { String id = request.param("id"); GetStoredScriptRequest getRequest = new GetStoredScriptRequest(id); getRequest.masterNodeTimeout(request.paramAsTime("master_timeout", getRequest.masterNodeTimeout())); return channel -> client.admin().cluster().getStoredScript(getRequest, new RestStatusToXContentListener<>(channel)); } }
@Override protected RestChannelConsumer doCatRequest(RestRequest request, NodeClient client) { GetRepositoriesRequest getRepositoriesRequest = new GetRepositoriesRequest(); getRepositoriesRequest.local(request.paramAsBoolean("local", getRepositoriesRequest.local())); getRepositoriesRequest.masterNodeTimeout(request.paramAsTime("master_timeout", getRepositoriesRequest.masterNodeTimeout())); return channel -> client.admin() .cluster() .getRepositories(getRepositoriesRequest, new RestResponseListener<GetRepositoriesResponse>(channel) { @Override public RestResponse buildResponse(GetRepositoriesResponse getRepositoriesResponse) throws Exception { return RestTable.buildResponse(buildTable(request, getRepositoriesResponse), channel); } }); }
@Override public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException { PendingClusterTasksRequest pendingClusterTasksRequest = new PendingClusterTasksRequest(); pendingClusterTasksRequest.masterNodeTimeout(request.paramAsTime("master_timeout", pendingClusterTasksRequest.masterNodeTimeout())); pendingClusterTasksRequest.local(request.paramAsBoolean("local", pendingClusterTasksRequest.local())); return channel -> client.admin().cluster().pendingClusterTasks(pendingClusterTasksRequest, new RestToXContentListener<>(channel)); } }
@Override public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) { final ClusterStateRequest clusterStateRequest = new ClusterStateRequest(); clusterStateRequest.clear().nodes(true); clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local())); clusterStateRequest.masterNodeTimeout(request.paramAsTime("master_timeout", clusterStateRequest.masterNodeTimeout())); return channel -> client.admin().cluster().state(clusterStateRequest, new RestResponseListener<ClusterStateResponse>(channel) { @Override public RestResponse buildResponse(final ClusterStateResponse clusterStateResponse) throws Exception { return RestTable.buildResponse(buildTable(request, clusterStateResponse), channel); } }); }
@Override public RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException { String id = request.param("id"); DeleteStoredScriptRequest deleteStoredScriptRequest = new DeleteStoredScriptRequest(id); deleteStoredScriptRequest.timeout(request.paramAsTime("timeout", deleteStoredScriptRequest.timeout())); deleteStoredScriptRequest.masterNodeTimeout(request.paramAsTime("master_timeout", deleteStoredScriptRequest.masterNodeTimeout())); return channel -> client.admin().cluster().deleteStoredScript(deleteStoredScriptRequest, new RestToXContentListener<>(channel)); } }
@Override protected RestChannelConsumer doCatRequest(final RestRequest request, NodeClient client) { final String matchPattern = request.hasParam("name") ? request.param("name") : null; final ClusterStateRequest clusterStateRequest = new ClusterStateRequest(); clusterStateRequest.clear().metaData(true); clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local())); clusterStateRequest.masterNodeTimeout(request.paramAsTime("master_timeout", clusterStateRequest.masterNodeTimeout())); return channel -> client.admin().cluster().state(clusterStateRequest, new RestResponseListener<ClusterStateResponse>(channel) { @Override public RestResponse buildResponse(ClusterStateResponse clusterStateResponse) throws Exception { return RestTable.buildResponse(buildTable(request, clusterStateResponse, matchPattern), channel); } }); }