private HttpUriBuilder getHttpUriBuilder(TaskStatus taskStatus) { HttpUriBuilder uriBuilder = uriBuilderFrom(taskStatus.getSelf()); if (summarizeTaskInfo) { uriBuilder.addParameter("summarize"); } return uriBuilder; }
@Override public URI createMemoryInfoLocation(Node node) { requireNonNull(node, "node is null"); return uriBuilderFrom(node.getHttpUri()) .appendPath("/v1/memory").build(); } }
@Override public URI createStageLocation(StageId stageId) { requireNonNull(stageId, "stageId is null"); return uriBuilderFrom(baseUri) .appendPath("v1/stage") .appendPath(stageId.toString()) .build(); }
@Override public URI createTaskLocation(Node node, TaskId taskId) { requireNonNull(node, "node is null"); requireNonNull(taskId, "taskId is null"); return uriBuilderFrom(node.getHttpUri()) .appendPath("/v1/task") .appendPath(taskId.toString()) .build(); }
@Override public URI createQueryLocation(QueryId queryId) { requireNonNull(queryId, "queryId is null"); return uriBuilderFrom(baseUri) .appendPath("/v1/query") .appendPath(queryId.toString()) .build(); }
@GET @Path("/v1/info") @Produces(APPLICATION_JSON) public void getInfo( @Context HttpServletRequest servletRequest, @Suspended AsyncResponse asyncResponse) { Request.Builder request = prepareGet() .setUri(uriBuilderFrom(remoteUri).replacePath("/v1/info").build()); performRequest(servletRequest, asyncResponse, request, response -> responseWithHeaders(Response.ok(response.getBody()), response)); }
private Response proxyJsonResponse(String nodeId, String workerPath) { Set<Node> nodes = nodeManager.getNodes(NodeState.ACTIVE); Node node = nodes.stream() .filter(n -> n.getNodeIdentifier().equals(nodeId)) .findFirst() .orElseThrow(() -> new WebApplicationException(NOT_FOUND)); Request request = prepareGet() .setUri(uriBuilderFrom(node.getHttpUri()) .appendPath(workerPath) .build()) .build(); InputStream responseStream = httpClient.execute(request, new StreamingJsonResponseHandler()); return Response.ok(responseStream, APPLICATION_JSON_TYPE).build(); }
private static void updateQueryOutputLocations(QueryStateMachine queryStateMachine, OutputBufferId rootBufferId, Set<RemoteTask> tasks, boolean noMoreExchangeLocations) { Set<URI> bufferLocations = tasks.stream() .map(task -> task.getTaskStatus().getSelf()) .map(location -> uriBuilderFrom(location).appendPath("results").appendPath(rootBufferId.toString()).build()) .collect(toImmutableSet()); queryStateMachine.updateOutputLocations(bufferLocations, noMoreExchangeLocations); }
@POST @Path("/v1/statement") @Produces(APPLICATION_JSON) public void postStatement( String statement, @Context HttpServletRequest servletRequest, @Context UriInfo uriInfo, @Suspended AsyncResponse asyncResponse) { Request.Builder request = preparePost() .setUri(uriBuilderFrom(remoteUri).replacePath("/v1/statement").build()) .setBodyGenerator(createStaticBodyGenerator(statement, UTF_8)); performRequest(servletRequest, asyncResponse, request, response -> buildResponse(uriInfo, response)); }
private void pollWorkers() { AllNodes allNodes = getAllNodes(); Set<Node> aliveNodes = ImmutableSet.<Node>builder() .addAll(allNodes.getActiveNodes()) .addAll(allNodes.getShuttingDownNodes()) .build(); ImmutableSet<String> aliveNodeIds = aliveNodes.stream() .map(Node::getNodeIdentifier) .collect(toImmutableSet()); // Remove nodes that don't exist anymore // Make a copy to materialize the set difference Set<String> deadNodes = difference(nodeStates.keySet(), aliveNodeIds).immutableCopy(); nodeStates.keySet().removeAll(deadNodes); // Add new nodes for (Node node : aliveNodes) { nodeStates.putIfAbsent(node.getNodeIdentifier(), new RemoteNodeState(httpClient, uriBuilderFrom(node.getHttpUri()).appendPath("/v1/info/state").build())); } // Schedule refresh nodeStates.values().forEach(RemoteNodeState::asyncRefresh); // update indexes refreshNodesInternal(); }
private long getTotalCpuTime() { long totalCpuTime = 0; for (URI server : nodes) { URI addressUri = uriBuilderFrom(server).replacePath("/v1/jmx/mbean/java.lang:type=OperatingSystem/ProcessCpuTime").build(); String data = httpClient.execute(prepareGet().setUri(addressUri).build(), createStringResponseHandler()).getBody(); totalCpuTime += parseLong(data.trim()); } return TimeUnit.NANOSECONDS.toNanos(totalCpuTime); }
private List<URI> getAllNodes(URI server) { Request request = prepareGet().setUri(uriBuilderFrom(server).replacePath("/v1/service/presto").build()).build(); JsonResponseHandler<ServiceDescriptorsRepresentation> responseHandler = createJsonResponseHandler(jsonCodec(ServiceDescriptorsRepresentation.class)); ServiceDescriptorsRepresentation serviceDescriptors = httpClient.execute(request, responseHandler); ImmutableList.Builder<URI> addresses = ImmutableList.builder(); for (ServiceDescriptor serviceDescriptor : serviceDescriptors.getServiceDescriptors()) { String httpUri = serviceDescriptor.getProperties().get("http"); if (httpUri != null) { addresses.add(URI.create(httpUri)); } } return addresses.build(); } }
public Response cancel(String queryId) { requireNonNull(queryId, "queryId is null"); URI cancelUri = uriBuilderFrom(uri).appendPath("/v1/query").appendPath(queryId).build(); Request request = prepareDelete().setUri(cancelUri).build(); return httpClient.execute(request, new ResponseHandler<Response, RuntimeException>() { @Override public Response handleException(Request request, Exception exception) { throw propagate(request, exception); } @Override public Response handle(Request request, Response response) { return response; } }); }
private static Split createRemoteSplitFor(TaskId taskId, URI taskLocation) { // Fetch the results from the buffer assigned to the task based on id URI splitLocation = uriBuilderFrom(taskLocation).appendPath("results").appendPath(String.valueOf(taskId.getId())).build(); return new Split(REMOTE_CONNECTOR_ID, new RemoteTransactionHandle(), new RemoteSplit(splitLocation)); }
public URI uriFor(String path) { return HttpUriBuilder.uriBuilderFrom(server.getBaseUrl()).replacePath(path).build(); } }
@Override public Optional<QueryStats> getQueryStats(String queryId) { URI uri = uriBuilderFrom(baseUri).appendPath("/v1/query").appendPath(queryId).build(); Request request = prepareGet().setUri(uri).build(); return httpClient.execute(request, new GetQueryStatsResponseHandler()); }
HttpUriBuilder httpUriBuilder = uriBuilderFrom(taskStatus.getSelf()); URI uri = summarizeTaskInfo ? httpUriBuilder.addParameter("summarize").build() : httpUriBuilder.build(); Request request = prepareGet()
private synchronized void scheduleNextRequest() { // stopped or done? TaskStatus taskStatus = getTaskStatus(); if (!running || taskStatus.getState().isDone()) { return; } // outstanding request? if (future != null && !future.isDone()) { // this should never happen log.error("Can not reschedule update because an update is already running"); return; } // if throttled due to error, asynchronously wait for timeout and try again ListenableFuture<?> errorRateLimit = errorTracker.acquireRequestPermit(); if (!errorRateLimit.isDone()) { errorRateLimit.addListener(this::scheduleNextRequest, executor); return; } Request request = prepareGet() .setUri(uriBuilderFrom(taskStatus.getSelf()).appendPath("status").build()) .setHeader(CONTENT_TYPE, JSON_UTF_8.toString()) .setHeader(PRESTO_CURRENT_STATE, taskStatus.getState().toString()) .setHeader(PRESTO_MAX_WAIT, refreshMaxWait.toString()) .build(); errorTracker.startRequest(); future = httpClient.executeAsync(request, createFullJsonResponseHandler(taskStatusCodec)); currentRequestStartNanos.set(System.nanoTime()); Futures.addCallback(future, new SimpleHttpResponseHandler<>(this, request.getUri(), stats), executor); }
@BeforeClass public void setup() { Request request1 = preparePost() .setUri(uriBuilderFrom(server.getBaseUrl()).replacePath("/v1/statement").build()) .setBodyGenerator(createStaticBodyGenerator(LONG_LASTING_QUERY, UTF_8)) .setHeader(PRESTO_USER, "user1") .build(); queryResults = client.execute(request1, createJsonResponseHandler(QUERY_RESULTS_JSON_CODEC)); client.execute(prepareGet().setUri(queryResults.getNextUri()).build(), createJsonResponseHandler(QUERY_RESULTS_JSON_CODEC)); Request request2 = preparePost() .setUri(uriBuilderFrom(server.getBaseUrl()).replacePath("/v1/statement").build()) .setBodyGenerator(createStaticBodyGenerator(LONG_LASTING_QUERY, UTF_8)) .setHeader(PRESTO_USER, "user2") .build(); QueryResults queryResults2 = client.execute(request2, createJsonResponseHandler(jsonCodec(QueryResults.class))); client.execute(prepareGet().setUri(queryResults2.getNextUri()).build(), createJsonResponseHandler(QUERY_RESULTS_JSON_CODEC)); // queries are started in the background, so they may not all be immediately visible while (true) { List<BasicQueryInfo> queryInfos = client.execute( prepareGet().setUri(uriBuilderFrom(server.getBaseUrl()).replacePath("/v1/query").build()).build(), createJsonResponseHandler(listJsonCodec(BasicQueryInfo.class))); if ((queryInfos.size() == 2) && queryInfos.stream().allMatch(info -> info.getState() == RUNNING)) { break; } } }
private void runToCompletion(String sql) { URI uri = uriBuilderFrom(server.getBaseUrl().resolve("/v1/statement")).build(); Request request = preparePost() .setHeader(PRESTO_USER, "user") .setUri(uri) .setBodyGenerator(createStaticBodyGenerator(sql, UTF_8)) .build(); QueryResults queryResults = client.execute(request, createJsonResponseHandler(jsonCodec(QueryResults.class))); while (queryResults.getNextUri() != null) { request = prepareGet() .setHeader(PRESTO_USER, "user") .setUri(queryResults.getNextUri()) .build(); queryResults = client.execute(request, createJsonResponseHandler(jsonCodec(QueryResults.class))); } }