@Test public void testServerStarts() { StatusResponseHandler.StatusResponse response = client.execute( prepareGet().setUri(server.resolve("/v1/query")).build(), createStatusResponseHandler()); assertEquals(response.getStatusCode(), OK.getStatusCode()); }
@Test public void testQuery() Request request = preparePost() .setUri(uriFor("/v1/statement")) .setBodyGenerator(createStaticBodyGenerator("show catalogs", UTF_8)) .setHeader(PRESTO_USER, "user") .setHeader(PRESTO_SOURCE, "source") .setHeader(PRESTO_CATALOG, "catalog") .setHeader(PRESTO_SCHEMA, "schema") .setHeader(PRESTO_PATH, "path") .setHeader(PRESTO_CLIENT_INFO, "{\"clientVersion\":\"testVersion\"}") .addHeader(PRESTO_SESSION, QUERY_MAX_MEMORY + "=1GB") .addHeader(PRESTO_SESSION, JOIN_DISTRIBUTION_TYPE + "=partitioned," + HASH_PARTITION_COUNT + " = 43") .addHeader(PRESTO_PREPARED_STATEMENT, "foo=select * from bar") .build(); QueryResults queryResults = client.execute(request, createJsonResponseHandler(QUERY_RESULTS_CODEC)); queryResults = client.execute(prepareGet().setUri(queryResults.getNextUri()).build(), createJsonResponseHandler(QUERY_RESULTS_CODEC)); assertNull(queryResults.getError()); assertEquals(queryInfo.getSession().getClientInfo().get(), "{\"clientVersion\":\"testVersion\"}");
@DELETE @Path("/v1/proxy") @Produces(APPLICATION_JSON) public void cancelQuery( @QueryParam("uri") String uri, @QueryParam("hmac") String hash, @Context HttpServletRequest servletRequest, @Suspended AsyncResponse asyncResponse) { if (!hmac.hashString(uri, UTF_8).equals(HashCode.fromString(hash))) { throw badRequest(FORBIDDEN, "Failed to validate HMAC of URI"); } Request.Builder request = prepareDelete().setUri(URI.create(uri)); performRequest(servletRequest, asyncResponse, request, response -> responseWithHeaders(noContent(), response)); }
@Test public void testUndefinedResource() { Request request = prepareGet() .setUri(URI.create("http://fake.invalid/unknown")) .build(); StringResponse response = HTTP_CLIENT.execute(request, createStringResponseHandler()); assertEquals(response.getStatusCode(), 404); }
@Test public void testGetSingle() throws IOException, ExecutionException, InterruptedException { store.put("foo", new Person("foo@example.com", "Mr Foo")); URI requestUri = uriFor("/v1/person/foo"); Map<String, Object> expected = mapCodec.fromJson(Resources.toString(Resources.getResource("single.json"), UTF_8)); expected.put("self", requestUri.toString()); Map<String, Object> actual = client.execute( prepareGet().setUri(requestUri).build(), createJsonResponseHandler(mapCodec)); assertEquals(actual, expected); }
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(); } }
@Test public void testSameRequestReturnedWhenTraceTokenNotSet() { TraceTokenManager manager = new TraceTokenManager(); TraceTokenRequestFilter filter = new TraceTokenRequestFilter(manager); Request original = prepareGet().setUri(URI.create("http://example.com")).build(); Request request = filter.filterRequest(original); assertSame(request, original); } }
@Test public void testBasicGet() throws Throwable { Map<String, Object> response = client.execute( prepareGet().setUri(server.getBaseUrl().resolve("/foo")).build(), createJsonResponseHandler(mapJsonCodec(String.class, Object.class))); assertEquals(response.get("REQUEST_METHOD"), "GET"); assertEquals(response.get("SCRIPT_NAME"), ""); assertEquals(response.get("PATH_INFO"), "/foo"); assertEquals(response.get("QUERY_STRING"), ""); }
@Test public void testGetFailedNodes() { List<Stats> nodes = client.execute( prepareGet().setUri(server.resolve("/v1/node/failed")).build(), createJsonResponseHandler(listJsonCodec(Stats.class))); assertTrue(nodes.isEmpty()); } }
@Test public void testTraceToken() { Request request = prepareGet().setUri(server.getBaseUrl().resolve("/testing/echo_token")).build(); StringResponse response = httpClient.execute(request, createStringResponseHandler()); assertEquals(response.getStatusCode(), SC_OK); assertEquals(response.getBody(), filter.getLastToken()); }
@Test public void testResponseStatusCode() throws Exception { servlet.setResponseStatusCode(543); Request request = prepareGet() .setUri(baseURI) .build(); int statusCode = executeRequest(request, createStatusResponseHandler()).getStatusCode(); assertEquals(statusCode, 543); }
@Test public void testGetQueryStateInfo() { QueryStateInfo info = client.execute( prepareGet().setUri(server.resolve("/v1/queryState/" + queryResults.getId())).build(), createJsonResponseHandler(jsonCodec(QueryStateInfo.class))); assertNotNull(info); }
@Test public void testTransactionSupport() { Request request = preparePost() .setUri(uriFor("/v1/statement")) .setBodyGenerator(createStaticBodyGenerator("start transaction", UTF_8)) .setHeader(PRESTO_USER, "user") .setHeader(PRESTO_SOURCE, "source") .setHeader(PRESTO_TRANSACTION_ID, "none") .build(); JsonResponse<QueryResults> queryResults = client.execute(request, createFullJsonResponseHandler(QUERY_RESULTS_CODEC)); ImmutableList.Builder<List<Object>> data = ImmutableList.builder(); while (true) { if (queryResults.getValue().getData() != null) { data.addAll(queryResults.getValue().getData()); } if (queryResults.getValue().getNextUri() == null) { break; } queryResults = client.execute(prepareGet().setUri(queryResults.getValue().getNextUri()).build(), createFullJsonResponseHandler(QUERY_RESULTS_CODEC)); } assertNull(queryResults.getValue().getError()); assertNotNull(queryResults.getHeader(PRESTO_STARTED_TRANSACTION_ID)); }
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))); } }
@Override public List<SlotStatusRepresentation> resetExpectedState(SlotFilter slotFilter, String expectedVersion) { URI uri = slotFilter.toUri(uriBuilderFrom(coordinatorUri).replacePath("/v1/slot/expected-state")); Request.Builder requestBuilder = Request.Builder.prepareDelete().setUri(uri); if (expectedVersion != null) { requestBuilder.setHeader(AIRSHIP_SLOTS_VERSION_HEADER, expectedVersion); } List<SlotStatusRepresentation> slots = client.execute(requestBuilder.build(), createJsonResponseHandler(SLOTS_CODEC)); return slots; }
@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 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 List<BasicQueryInfo> getQueryInfos(String path) { Request request = prepareGet().setUri(server.resolve(path)).build(); return client.execute(request, createJsonResponseHandler(listJsonCodec(BasicQueryInfo.class))); }
private synchronized void sendDelete() HttpResponseFuture<StatusResponse> resultFuture = httpClient.executeAsync(prepareDelete().setUri(location).build(), createStatusResponseHandler()); future = resultFuture; Futures.addCallback(resultFuture, new FutureCallback<StatusResponse>()
outputBuffers.get(), totalPartitions); byte[] taskUpdateRequestJson = taskUpdateRequestCodec.toJsonBytes(updateRequest); if (fragment.isPresent()) { stats.updateWithPlanBytes(taskUpdateRequestJson.length); Request request = preparePost() .setUri(uriBuilder.build()) .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.JSON_UTF_8.toString()) .setBodyGenerator(createStaticBodyGenerator(taskUpdateRequestJson)) .build(); ListenableFuture<JsonResponse<TaskInfo>> future = httpClient.executeAsync(request, createFullJsonResponseHandler(taskInfoCodec)); currentRequest = future; currentRequestStartNanos = System.nanoTime();