Examples with MultiplexedResponseContent com.linkedin.restli.common.multiplexer.MultiplexedResponseContent used on opensource projects

Example 1 with MultiplexedResponseContent

use of com.linkedin.restli.common.multiplexer.MultiplexedResponseContent in project rest.li by linkedin.

the class TestMultiplexedCallback method testMixed.

@Test
public void testMixed() throws Exception {
    FutureCallback<RestResponse> callback1 = new FutureCallback<>();
    FutureCallback<RestResponse> callback2 = new FutureCallback<>();
    ImmutableMap<Integer, Callback<RestResponse>> individualCallbacks = ImmutableMap.<Integer, Callback<RestResponse>>of(ID1, callback1, ID2, callback2);
    FutureCallback<MultiplexedResponse> aggregatedCallback = new FutureCallback<>();
    TestRecord entity1 = fakeEntity(ID1);
    IndividualResponse ir1 = fakeIndividualResponse(entity1);
    IndividualResponse ir2 = fakeIndividualErrorResponse();
    MultiplexedResponseContent responseContent = new MultiplexedResponseContent().setResponses(new IndividualResponseMap(ImmutableMap.of(Integer.toString(ID1), ir1, Integer.toString(ID2), ir2)));
    MultiplexedCallback multiplexedCallback = new MultiplexedCallback(individualCallbacks, aggregatedCallback);
    multiplexedCallback.onSuccess(fakeRestResponse(responseContent));
    assertRestResponseEquals(callback1.get(), fakeRestResponse(entity1));
    RestException actualError = (RestException) getError(callback2);
    assertRestResponseEquals(actualError.getResponse(), fakeRestErrorResponse());
    MultiplexedResponse multiplexedResponse = aggregatedCallback.get();
    Assert.assertEquals(multiplexedResponse.getStatus(), HttpStatus.S_200_OK.getCode());
    Assert.assertEquals(multiplexedResponse.getHeaders(), HEADERS);
}

Example 2 with MultiplexedResponseContent

use of com.linkedin.restli.common.multiplexer.MultiplexedResponseContent in project rest.li by linkedin.

the class MultiplexedRequestHandlerImpl method aggregateResponses.

private static RestResponse aggregateResponses(IndividualResponseMap responses, Map<String, HttpCookie> responseCookies) {
    MultiplexedResponseContent aggregatedResponseContent = new MultiplexedResponseContent();
    aggregatedResponseContent.setResponses(responses);
    ByteString aggregatedResponseData = DataMapUtils.mapToByteString(aggregatedResponseContent.data(), Collections.singletonMap(RestConstants.HEADER_CONTENT_TYPE, RestConstants.HEADER_VALUE_APPLICATION_JSON));
    return new RestResponseBuilder().setStatus(HttpStatus.S_200_OK.getCode()).setEntity(aggregatedResponseData).setCookies(CookieUtil.encodeSetCookies(new ArrayList<>(responseCookies.values()))).build();
}

Example 3 with MultiplexedResponseContent

use of com.linkedin.restli.common.multiplexer.MultiplexedResponseContent in project rest.li by linkedin.

the class TestMultiplexedRequestHandlerImpl method testRequestHeaderWhiteListing.

@Test(dataProvider = "multiplexerConfigurations")
public void testRequestHeaderWhiteListing(MultiplexerRunMode multiplexerRunMode) throws Exception {
    // Validating request header white listing logic
    // Create a mockHandler.  Make it return different cookies based on the request
    SynchronousRequestHandler mockHandler = new SynchronousRequestHandler() {

        @Override
        public RestResponse handleRequestSync(RestRequest request, RequestContext requestContext) {
            try {
                return fakeIndRestResponse(jsonBodyToByteString(fakeIndividualBody("foobar")));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
    // Prepare request to mux handler
    FutureCallback<RestResponse> callback = new FutureCallback<>();
    RequestContext requestContext = new RequestContext();
    Map<String, IndividualRequest> individualRequests = ImmutableMap.of("0", fakeIndRequest("/request1", ImmutableMap.of("x-I-am-a-good-Header", "headerValue"), Collections.<String, IndividualRequest>emptyMap()), "1", fakeIndRequest("/request2", ImmutableMap.of("X-Malicious-Header", "evilHeader"), Collections.<String, IndividualRequest>emptyMap()));
    Set<String> headerWhiteList = new HashSet<>();
    headerWhiteList.add("X-I-AM-A-GOOD-HEADER");
    // Create mux handler instance
    MultiplexedRequestHandlerImpl multiplexer = createMultiplexer(mockHandler, null, headerWhiteList, individualRequests.size(), multiplexerRunMode);
    try {
        multiplexer.handleRequest(fakeMuxRestRequest(individualRequests), requestContext, callback);
    } catch (Exception e) {
        fail("Multiplexer should not throw exception", e);
    }
    RestResponse muxRestResponse = callback.get();
    // Assert multiplexed request should return a 200 status code
    assertEquals(muxRestResponse.getStatus(), 200, "Multiplexer should return 200");
    MultiplexedResponseContent muxResponseContent = new MultiplexedResponseContent(DataMapConverter.bytesToDataMap(muxRestResponse.getHeaders(), muxRestResponse.getEntity()));
    assertEquals(muxResponseContent.getResponses().get("0").getStatus().intValue(), 200, "Request with whitelisted request header should complete successfully");
    assertEquals(muxResponseContent.getResponses().get("1").getStatus().intValue(), 400, "Request with non-whitelisted request header should receive a 400 bad request error");
}

Example 4 with MultiplexedResponseContent

use of com.linkedin.restli.common.multiplexer.MultiplexedResponseContent in project rest.li by linkedin.

the class TestMultiplexedRequestHandlerImpl method testMultiplexedSingletonFilterFailures.

@Test(dataProvider = "multiplexerConfigurations")
public void testMultiplexedSingletonFilterFailures(MultiplexerRunMode multiplexerRunMode) throws Exception {
    // This test validates when a failure occurred in MultiplexedSingletonFilter for an individual request, only the individual
    // request should fail. The multiplexed request should still be completed successfully with a 200 status code.
    // Setup mock request handler: make handler return a json that contains the request uri
    // We are using this uri in our mock MultiplexerSingletonFilter.filterIndividualResponse function so that
    // we can simulate different response based on the request.
    SynchronousRequestHandler mockHandler = new SynchronousRequestHandler() {

        @Override
        public RestResponse handleRequestSync(RestRequest request, RequestContext requestContext) {
            try {
                return fakeIndRestResponse(jsonBodyToByteString(fakeIndividualBody(request.getURI().toString())));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
    // Create a mock MultiplexerSingletonFilter to it simulate different type of failures.
    // Failure is simulated are base on the request uri.
    MultiplexerSingletonFilter muxFilterWithSimulatedFailures = new MultiplexerSingletonFilter() {

        @Override
        public IndividualRequest filterIndividualRequest(IndividualRequest request) {
            if (request.getRelativeUrl().contains("bad_request")) {
                throw new RestLiServiceException(HttpStatus.S_400_BAD_REQUEST, "not found");
            } else if (request.getRelativeUrl().contains("error_request")) {
                throw new IllegalArgumentException("Something really bad happened in filterIndividualRequest");
            }
            return request;
        }

        @Override
        public IndividualResponse filterIndividualResponse(IndividualResponse response) {
            if (response.getStatus() == HttpStatus.S_200_OK.getCode()) {
                if (response.getBody().data().getString("value").contains("notfound_response")) {
                    throw new RestLiServiceException(HttpStatus.S_404_NOT_FOUND, "not found");
                } else if (response.getBody().data().getString("value").contains("error_response")) {
                    // simulate an unexpected exception
                    throw new UnsupportedOperationException("Something really bad happened in filterIndividualResponse");
                }
            }
            return response;
        }
    };
    // Prepare request to mux handler
    FutureCallback<RestResponse> callback = new FutureCallback<>();
    RequestContext requestContext = new RequestContext();
    Map<String, IndividualRequest> individualRequests = new HashMap<>();
    individualRequests.put("0", fakeIndRequest("/good_request"));
    individualRequests.put("1", fakeIndRequest("/bad_request"));
    individualRequests.put("2", fakeIndRequest("/error_request"));
    individualRequests.put("3", fakeIndRequest("/notfound_response"));
    individualRequests.put("4", fakeIndRequest("/error_response"));
    individualRequests.put("5", fakeIndRequest("/good_request", ImmutableMap.of("6", fakeIndRequest("/bad_request"))));
    RestRequest request = fakeMuxRestRequest(individualRequests);
    // Create mux handler instance
    MultiplexedRequestHandlerImpl multiplexer = createMultiplexer(mockHandler, muxFilterWithSimulatedFailures, Collections.<String>emptySet(), 10, multiplexerRunMode);
    try {
        multiplexer.handleRequest(request, requestContext, callback);
    } catch (Exception e) {
        fail("Multiplexer should not blow up because one of the individual requests failed", e);
    }
    RestResponse muxRestResponse = callback.get();
    // Assert multiplexed request should return a 200 status code
    assertEquals(muxRestResponse.getStatus(), 200, "Failure in indivudal request should not cause the entire multliplexed request to fail");
    MultiplexedResponseContent muxResponseContent = new MultiplexedResponseContent(DataMapConverter.bytesToDataMap(muxRestResponse.getHeaders(), muxRestResponse.getEntity()));
    IndividualResponseMap responses = muxResponseContent.getResponses();
    // Validate the status code for each of the response
    assertEquals(responses.get("0").getStatus().intValue(), 200, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("1").getStatus().intValue(), 400, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("2").getStatus().intValue(), 500, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("3").getStatus().intValue(), 404, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("4").getStatus().intValue(), 500, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("5").getStatus().intValue(), 200, "Mux response body is: " + responses.toString());
    assertEquals(responses.get("6").getStatus().intValue(), 400, "Mux response body is: " + responses.toString());
}

Example 5 with MultiplexedResponseContent

use of com.linkedin.restli.common.multiplexer.MultiplexedResponseContent in project rest.li by linkedin.

the class TestMultiplexedRequestHandlerImpl method fakeMuxRestResponse.

private static RestResponse fakeMuxRestResponse(Map<Integer, IndividualResponse> responses) throws IOException {
    IndividualResponseMap individualResponseMap = new IndividualResponseMap();
    for (Map.Entry<Integer, IndividualResponse> responseMapEntry : responses.entrySet()) {
        individualResponseMap.put(Integer.toString(responseMapEntry.getKey()), responseMapEntry.getValue());
    }
    MultiplexedResponseContent content = new MultiplexedResponseContent();
    content.setResponses(individualResponseMap);
    return new RestResponseBuilder().setStatus(HttpStatus.S_200_OK.getCode()).setEntity(CODEC.mapToBytes(content.data())).build();
}