public String getStoreClientConfigString(List<String> storeNames, String coordinatorUrl) { try { // Create the REST request StringBuilder URIStringBuilder = new StringBuilder().append(coordinatorUrl) .append(URL_SEPARATOR) .append(STORE_CLIENT_CONFIG_OPS) .append(URL_SEPARATOR) .append(Joiner.on(",") .join(storeNames)); RestRequestBuilder requestBuilder = new RestRequestBuilder(new URI(URIStringBuilder.toString())); String timeoutStr = Long.toString(this.config.getTimeoutConfig() .getOperationTimeout(VoldemortOpCode.GET_OP_CODE)); requestBuilder.setMethod(requestType.GET.toString()); requestBuilder.setHeader(RestMessageHeaders.X_VOLD_REQUEST_TIMEOUT_MS, timeoutStr); requestBuilder = setCommonRequestHeader(requestBuilder); RestRequest request = requestBuilder.build(); Future<RestResponse> future = client.restRequest(request); // This will block RestResponse response = future.get(); ByteString entity = response.getEntity(); return entity.asString("UTF-8"); } catch(Exception e) { if(e.getCause() instanceof RestException) { return ((RestException) e.getCause()).getResponse().getEntity().asString("UTF-8"); } handleRequestAndResponseException(e); } return null; }
try { String base64Key = new String(Base64.encodeBase64(getName().getBytes("UTF-8"))); rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + SCHEMATA_STORE_NAME + "/" + base64Key)); rb.setHeader("Accept", "binary");
RestRequestBuilder rb = null; try { rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + getName() + "/" + base64Key)); String timeoutStr = Long.toString(this.config.getTimeoutConfig()
RestRequestBuilder rb = null; try { rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + getName() + "/" + base64Key)); String timeoutStr = Long.toString(this.config.getTimeoutConfig()
.append(Joiner.on(",") .join(storeNames)); RestRequestBuilder requestBuilder = new RestRequestBuilder(new URI(URIStringBuilder.toString())); String timeoutStr = Long.toString(this.config.getTimeoutConfig() .getOperationTimeout(VoldemortOpCode.GET_OP_CODE));
} else { RestRequestBuilder rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + getName() + "/" + keyArgs.toString()));
.append(STORE_CLIENT_CONFIG_OPS) .append(URL_SEPARATOR); RestRequestBuilder requestBuilder = new RestRequestBuilder(new URI(URIStringBuilder.toString()));
RestRequestBuilder rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + getName() + "/" + base64Key));
RestRequestBuilder rb = new RestRequestBuilder(new URI(this.restBootstrapURL + "/" + getName() + "/" + base64Key));
verify(builder).build(requestBuilderArgument.capture()); RestRequestBuilder expected = new RestRequestBuilder(new URI("http://www.test.com/a/part1:01/a/part2:02?param1=01")); expected.setMethod("PUT"); expected.setHeader(RestConstants.HEADER_RESTLI_PROTOCOL_VERSION, protocolVersion);
@Test(dataProvider = "responseCompressionData") public void testResponseCompressionRules(CompressionConfig responseCompressionConfig, CompressionOption responseCompressionOverride, String expectedAcceptEncoding, String expectedCompressionThreshold, String operation) throws CompressionException, URISyntaxException { ClientCompressionFilter clientCompressionFilter = new ClientCompressionFilter(EncodingType.SNAPPY.getHttpName(), new CompressionConfig(Integer.MAX_VALUE), ACCEPT_COMPRESSIONS, responseCompressionConfig, Arrays.asList(ClientCompressionHelper.COMPRESS_ALL_RESPONSES_INDICATOR)); RestRequest restRequest = new RestRequestBuilder(new URI(URI)).build(); RequestContext context = new RequestContext(); if (operation != null) { context.putLocalAttr(R2Constants.OPERATION, operation); } context.putLocalAttr(R2Constants.RESPONSE_COMPRESSION_OVERRIDE, responseCompressionOverride); clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.ACCEPT_ENCODING, expectedAcceptEncoding)); clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, expectedCompressionThreshold)); }
@Test(dataProvider = "requestCompressionData") public void testRequestCompressionRules(CompressionConfig requestCompressionConfig, CompressionOption requestCompressionOverride, boolean headerShouldBePresent) throws CompressionException, URISyntaxException { ClientCompressionFilter clientCompressionFilter = new ClientCompressionFilter(EncodingType.SNAPPY.getHttpName(), requestCompressionConfig, ACCEPT_COMPRESSIONS, new CompressionConfig(Integer.MAX_VALUE), Collections.<String>emptyList()); // The entity should be compressible for this test. int original = 100; byte[] entity = new byte[original]; Arrays.fill(entity, (byte)'A'); RestRequest restRequest = new RestRequestBuilder(new URI(URI)).setMethod(RestMethod.POST).setEntity(entity).build(); int compressed = EncodingType.SNAPPY.getCompressor().deflate(new ByteArrayInputStream(entity)).length; RequestContext context = new RequestContext(); context.putLocalAttr(R2Constants.REQUEST_COMPRESSION_OVERRIDE, requestCompressionOverride); int entityLength = headerShouldBePresent ? compressed : original; String expectedContentEncoding = headerShouldBePresent ? EncodingType.SNAPPY.getHttpName() : null; clientCompressionFilter.onRestRequest(restRequest, context, Collections.<String, String>emptyMap(), new HeaderCaptureFilter(HttpConstants.CONTENT_ENCODING, expectedContentEncoding, entityLength)); }
RestRequestBuilder builder = new RestRequestBuilder(uri).setMethod(method.getHttpMethod().toString());
@Override public RestRequestBuilder builder() { return new RestRequestBuilder(this); }
private TopLevelReaderCallback(RoutingResult routingResult, final Callback<StreamResponse> streamResponseCallback, final MultiPartMIMEReader multiPartMIMEReader, final StreamRequest streamRequest) { _routingResult = routingResult; _restRequestBuilder = new RestRequestBuilder(streamRequest); _streamResponseCallback = streamResponseCallback; _multiPartMIMEReader = multiPartMIMEReader; }
public static RestRequest simpleRestRequest() { return new RestRequestBuilder(URI.create("simple_uri")) .build(); }
@Override @Deprecated public RestRequest getRawRequest() { if (_request instanceof RestRequest) { return (RestRequest) _request; } // The content of the entity stream is not copied to the RestRequest. Reading the content is challenging because the entity // stream can only be read once. However, this is acceptable in this deprecated method because no application // depends on the entity content. return new RestRequestBuilder((StreamRequest) _request).build(); }
/** * @param method of the HttpRequest ({@link com.linkedin.r2.message.rest.RestMethod}) * @param uri full URI of the request */ public RestRequest buildRestRequest(String method, URI uri) { RestRequestBuilder requestBuilder = new RestRequestBuilder(uri); requestBuilder.setMethod(method); requestBuilder.setHeader("X-RestLi-Protocol-Version", "2.0.0"); return requestBuilder.build(); }
@Override public RestRequest readRestRequest(InputStream in) throws IOException { final RestRequestBuilder builder = new RestRequestBuilder(URI.create("")); readReqLine(builder, in); readHeaders(builder, in, HttpConstants.REQUEST_COOKIE_HEADER_NAME); builder.setEntity(readEntity(in)); return builder.build(); }
private static RestRequest createSyntheticRequest(RestRequest envelopeRequest, IndividualRequest individualRequest) throws MimeTypeParseException, IOException { URI uri = URI.create(individualRequest.getRelativeUrl()); ByteString entity = getBodyAsByteString(individualRequest); return new RestRequestBuilder(uri) .setMethod(individualRequest.getMethod()) .setHeaders(individualRequest.getHeaders()) .setCookies(envelopeRequest.getCookies()) .setEntity(entity) .build(); }