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; }
headers.remove(HttpConstants.CONTENT_ENCODING); headers.put(HttpConstants.CONTENT_LENGTH, Integer.toString(decompressedContent.length)); req = req.builder().setEntity(decompressedContent).setHeaders(headers).build();
private RestResponse fetchGetResponse(RestRequestBuilder requestBuilder, String timeoutStr) throws InterruptedException, ExecutionException { requestBuilder.setMethod(GET); requestBuilder.setHeader(RestMessageHeaders.X_VOLD_REQUEST_TIMEOUT_MS, timeoutStr); requestBuilder.setHeader(RestMessageHeaders.X_VOLD_REQUEST_ORIGIN_TIME_MS, String.valueOf(System.currentTimeMillis())); if(this.routingTypeCode != null) { requestBuilder.setHeader(RestMessageHeaders.X_VOLD_ROUTING_TYPE_CODE, this.routingTypeCode); } if(this.zoneId != INVALID_ZONE_ID) { requestBuilder.setHeader(RestMessageHeaders.X_VOLD_ZONE_ID, String.valueOf(this.zoneId)); } RestRequest request = requestBuilder.build(); Future<RestResponse> f = client.restRequest(request); // This will block return f.get(); }
/** * Builds HTTP headers related to response compression and creates a RestRequest with those headers added. * * @param responseCompressionOverride compression force on/off override from the request context. * @param req current request. * @return request with response compression headers. */ public RestRequest addResponseCompressionHeaders(CompressionOption responseCompressionOverride, RestRequest req) { RestRequestBuilder builder = req.builder(); if (responseCompressionOverride == null) { builder.addHeaderValue(HttpConstants.ACCEPT_ENCODING, _acceptEncodingHeader); if (_responseCompressionConfig != null) { builder.addHeaderValue(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, Integer.toString(_responseCompressionConfig.getCompressionThreshold())); } } else if (responseCompressionOverride == CompressionOption.FORCE_ON) { builder.addHeaderValue(HttpConstants.ACCEPT_ENCODING, _acceptEncodingHeader) .addHeaderValue(HttpConstants.HEADER_RESPONSE_COMPRESSION_THRESHOLD, Integer.toString(0)); } return builder.build(); }
/** * Add payload to request. By default, payload is sent as application/json */ protected int addPayload(RestRequestBuilder builder, String payload) { if (payload == null || payload.length() == 0) { return 0; } builder.setHeader(RestConstants.HEADER_CONTENT_TYPE, RestConstants.HEADER_VALUE_APPLICATION_JSON); try { DataMap data = JACKSON_DATA_CODEC.stringToMap(payload); byte[] bytes = JACKSON_DATA_CODEC.mapToBytes(data); builder.setEntity(bytes); return bytes.length; } catch (IOException e) { throw new RuntimeException("Fail to convert payload: " + payload, e); } }
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(); }
@SuppressWarnings("unchecked") public static <T extends RecordTemplate> PatchRequest<T> buildPatchFromString(String patch) { PatchRequest<T> patchRequest = null; try { RestRequest restRequest = new RestRequestBuilder(new URI("/test")).setEntity(patch.getBytes()).build(); patchRequest = (PatchRequest<T>) ArgumentBuilder.extractEntity(restRequest, PatchRequest.class); } catch (URISyntaxException e) { } return patchRequest; } }
RestRequestBuilder requestBuilder = new RestRequestBuilder(request); URI uri = request.getURI(); if (entity == null || entity.length() == 0) requestBuilder.setHeader(HEADER_CONTENT_TYPE, FORM_URL_ENCODED); requestBuilder.setEntity(ByteString.copyString(uri.getRawQuery(), Data.UTF_8_CHARSET)); requestBuilder.setHeader(HEADER_CONTENT_TYPE, multi.getContentType()); ByteArrayOutputStream os = new ByteArrayOutputStream(); multi.writeTo(os); requestBuilder.setEntity(ByteString.copy(os.toByteArray())); requestBuilder.setURI(newUri); requestBuilder.setHeader(HEADER_METHOD_OVERRIDE, requestBuilder.getMethod()); requestBuilder.setHeader(CONTENT_LENGTH, Integer.toString(requestBuilder.getEntity().length())); requestBuilder.setMethod(RestMethod.POST); return requestBuilder.build();
RestRequestBuilder builder = new RestRequestBuilder(uri).setMethod(method.getHttpMethod().toString()); builder.setHeaders(headers); builder.setHeader(RestConstants.HEADER_RESTLI_PROTOCOL_VERSION, protocolVersion); builder.setHeader(RestConstants.HEADER_RESTLI_REQUEST_METHOD, method.toString());
RestRequestBuilder rb = new RestRequestBuilder(uri); rb.setMethod(req.getMethod()); rb.addCookie(cookies.nextElement()); rb.addHeaderValue(headerName, headerValues.nextElement()); if (length > 0) rb.setEntity(ByteString.read(req.getInputStream(), length)); rb.setEntity(ByteString.read(req.getInputStream())); return rb.build();
RestRequestBuilder builder = new RestRequestBuilder(uri); builder.setMethod(nettyRequest.method().name()); for (Map.Entry<String, String> e : nettyRequest.headers()) builder.addCookie(e.getValue()); builder.unsafeAddHeaderValue(e.getKey(), e.getValue()); builder.setEntity(entity); out.add(builder.build());
requestBuilder.setURI(new URI(request.getURI().toString() + separator + query)); requestBuilder.setEntity(entity); requestBuilder.setHeaders(h); requestBuilder.setMethod(request.getHeader(HEADER_METHOD_OVERRIDE)); return requestBuilder.build();
@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)); }
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"); rb.setHeader(RestMessageHeaders.X_VOLD_REQUEST_ORIGIN_TIME_MS, String.valueOf(System.currentTimeMillis())); if(this.routingTypeCode != null) { rb.setHeader(RestMessageHeaders.X_VOLD_ROUTING_TYPE_CODE, this.routingTypeCode); rb.setHeader(RestMessageHeaders.X_VOLD_ZONE_ID, String.valueOf(this.zoneId));
/** * Default constructor. * * @throws RestLiSyntaxException cannot happen here */ public ResourceContextImpl() throws RestLiSyntaxException { this(new PathKeysImpl(), new RestRequestBuilder(URI.create("")) .setHeader(RestConstants.HEADER_RESTLI_PROTOCOL_VERSION, AllProtocolVersions.LATEST_PROTOCOL_VERSION.toString()) .build(), new RequestContext()); }
@Override public void handleRequest(final RestRequest request, final RequestContext requestContext, final Callback<RestResponse> callback) { // Create a new request at this point from the debug request by removing the path suffix // starting with "__debug". String fullPath = request.getURI().getPath(); int debugSegmentIndex = fullPath.indexOf(DEBUG_PATH_SEGMENT); RestRequestBuilder requestBuilder = new RestRequestBuilder(request); UriBuilder uriBuilder = UriBuilder.fromUri(request.getURI()); uriBuilder.replacePath(request.getURI().getPath().substring(0, debugSegmentIndex - 1)); requestBuilder.setURI(uriBuilder.build()); _restLiServer.handleResourceRequest(requestBuilder.build(), requestContext, callback); } }
/** * Combine the specified {@link RestRequest} and map of headers to construct a new * {@link RestRequest}. * * @param request the {@link RestRequest} to be used as a source object. * @param headers the headers to set on the request. These override any headers on the * source request. * @return a new {@link RestRequest} which combines the specified request and headers. */ public static RestRequest toRestRequest(RestRequest request, Map<String, String> headers) { return new RestRequestBuilder(request) .unsafeSetHeaders(headers) .build(); }
long requestTimeout) { final RestRequest newRequest = new RestRequestBuilder(request) .overwriteHeaders(WireAttributeHelper.toWireAttributes(wireAttrs)) .build();