Examples with ResponseInfo com.nike.riposte.server.http.ResponseInfo used on opensource projects

Example 1 with ResponseInfo

use of com.nike.riposte.server.http.ResponseInfo in project riposte by Nike-Inc.

the class NonblockingEndpointExecutionHandler method doChannelRead.

@Override
public PipelineContinuationBehavior doChannelRead(ChannelHandlerContext ctx, Object msg) {
    HttpProcessingState state = ChannelAttributes.getHttpProcessingStateForChannel(ctx).get();
    Endpoint<?> endpoint = state.getEndpointForExecution();
    if (shouldHandleDoChannelReadMessage(msg, endpoint)) {
        // We only do something when the last chunk of content has arrived.
        if (msg instanceof LastHttpContent) {
            NonblockingEndpoint nonblockingEndpoint = ((NonblockingEndpoint) endpoint);
            // We're supposed to execute the endpoint. There may be pre-endpoint-execution validation logic or
            // other work that needs to happen before the endpoint is executed, so set up the
            // CompletableFuture for the endpoint call to only execute if the pre-endpoint-execution
            // validation/work chain is successful.
            RequestInfo<?> requestInfo = state.getRequestInfo();
            Span endpointExecutionSpan = findEndpointExecutionSpan(state);
            CompletableFuture<ResponseInfo<?>> responseFuture = state.getPreEndpointExecutionWorkChain().thenCompose(doExecuteEndpointFunction(requestInfo, nonblockingEndpoint, endpointExecutionSpan, ctx));
            // Register an on-completion callback so we can be notified when the CompletableFuture finishes.
            responseFuture.whenComplete((responseInfo, throwable) -> {
                // full details on why this needs to be done here.
                if (endpointExecutionSpan != null && spanTaggingStrategy.shouldAddEndpointFinishAnnotation()) {
                    addEndpointFinishAnnotation(endpointExecutionSpan, spanTaggingStrategy);
                }
                // Kick off the response processing, depending on whether the result is an error or not.
                if (throwable != null)
                    asyncErrorCallback(ctx, throwable);
                else
                    asyncCallback(ctx, responseInfo);
            });
            // TODO: We might be able to put the timeout future in an if block in the case that the endpoint
            // returned an already-completed future (i.e. if responseFuture.isDone() returns true at this
            // point).
            // Also schedule a timeout check with our Netty event loop to make sure we kill the
            // CompletableFuture if it goes on too long.
            Long endpointTimeoutOverride = nonblockingEndpoint.completableFutureTimeoutOverrideMillis();
            long timeoutValueToUse = (endpointTimeoutOverride == null) ? defaultCompletableFutureTimeoutMillis : endpointTimeoutOverride;
            ScheduledFuture<?> responseTimeoutScheduledFuture = ctx.channel().eventLoop().schedule(() -> {
                if (!responseFuture.isDone()) {
                    runnableWithTracingAndMdc(() -> logger.error("A non-blocking endpoint's CompletableFuture did not finish within " + "the allotted timeout ({} milliseconds). Forcibly cancelling it.", timeoutValueToUse), ctx).run();
                    @SuppressWarnings("unchecked") Throwable errorToUse = nonblockingEndpoint.getCustomTimeoutExceptionCause(requestInfo, ctx);
                    if (errorToUse == null)
                        errorToUse = new NonblockingEndpointCompletableFutureTimedOut(timeoutValueToUse);
                    responseFuture.completeExceptionally(errorToUse);
                }
            }, timeoutValueToUse, TimeUnit.MILLISECONDS);
            /*
                    The problem with the scheduled timeout check is that it holds on to the RequestInfo,
                    ChannelHandlerContext, and a bunch of other stuff that *should* become garbage the instant the
                    request finishes, but because of the timeout check it has to wait until the check executes
                    before the garbage is collectible. In high volume servers the default 60 second timeout is way
                    too long and acts like a memory leak and results in garbage collection thrashing if the
                    available memory can be filled within the 60 second timeout. To combat this we cancel the
                    timeout future when the endpoint future finishes. Netty will remove the cancelled timeout future
                    from its scheduled list within a short time, thus letting the garbage be collected.
                */
            responseFuture.whenComplete((responseInfo, throwable) -> {
                if (!responseTimeoutScheduledFuture.isDone())
                    responseTimeoutScheduledFuture.cancel(false);
            });
        }
        // completes (see asyncCallback() and asyncErrorCallback()).
        return PipelineContinuationBehavior.DO_NOT_FIRE_CONTINUE_EVENT;
    }
    // error to be returned to the client.
    return PipelineContinuationBehavior.CONTINUE;
}

Example 2 with ResponseInfo

use of com.nike.riposte.server.http.ResponseInfo in project riposte by Nike-Inc.

the class RequestFilterHandler method doChannelRead.

@Override
public PipelineContinuationBehavior doChannelRead(ChannelHandlerContext ctx, Object msg) {
    if (msg instanceof HttpRequest) {
        HttpProcessingState state = ChannelAttributes.getHttpProcessingStateForChannel(ctx).get();
        handlerUtils.createRequestInfoFromNettyHttpRequestAndHandleStateSetupIfNecessary((HttpRequest) msg, state);
        // If the Netty HttpRequest is invalid, we shouldn't process any of the filters.
        handlerUtils.throwExceptionIfNotSuccessfullyDecoded((HttpRequest) msg);
        // The HttpRequest is valid, so process the filters.
        BiFunction<RequestAndResponseFilter, RequestInfo, RequestInfo> normalFilterCall = (filter, request) -> filter.filterRequestFirstChunkNoPayload(request, ctx);
        BiFunction<RequestAndResponseFilter, RequestInfo, Pair<RequestInfo, Optional<ResponseInfo<?>>>> shortCircuitFilterCall = (filter, request) -> filter.filterRequestFirstChunkWithOptionalShortCircuitResponse(request, ctx);
        return handleFilterLogic(ctx, msg, state, normalFilterCall, shortCircuitFilterCall);
    }
    if (msg instanceof LastHttpContent) {
        HttpProcessingState state = ChannelAttributes.getHttpProcessingStateForChannel(ctx).get();
        BiFunction<RequestAndResponseFilter, RequestInfo, RequestInfo> normalFilterCall = (filter, request) -> filter.filterRequestLastChunkWithFullPayload(request, ctx);
        BiFunction<RequestAndResponseFilter, RequestInfo, Pair<RequestInfo, Optional<ResponseInfo<?>>>> shortCircuitFilterCall = (filter, request) -> filter.filterRequestLastChunkWithOptionalShortCircuitResponse(request, ctx);
        return handleFilterLogic(ctx, msg, state, normalFilterCall, shortCircuitFilterCall);
    }
    // Not the first or last chunk. No filters were executed, so continue normally.
    return PipelineContinuationBehavior.CONTINUE;
}

Example 3 with ResponseInfo

use of com.nike.riposte.server.http.ResponseInfo in project riposte by Nike-Inc.

the class RequestAndResponseFilterTest method default_method_implementations_behave_as_expected.

@Test
public void default_method_implementations_behave_as_expected() {
    // given
    RequestAndResponseFilter defaultImpl = new RequestAndResponseFilter() {

        @Override
        @Nullable
        public <T> RequestInfo<T> filterRequestFirstChunkNoPayload(@NotNull RequestInfo<T> currentRequestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }

        @Override
        @Nullable
        public <T> RequestInfo<T> filterRequestLastChunkWithFullPayload(@NotNull RequestInfo<T> currentRequestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }

        @Override
        @Nullable
        public <T> ResponseInfo<T> filterResponse(@NotNull ResponseInfo<T> currentResponseInfo, @NotNull RequestInfo<?> requestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }
    };
    // expect
    assertThat(defaultImpl.isShortCircuitRequestFilter()).isFalse();
    Throwable firstChunkShortCircuitEx = catchThrowable(() -> defaultImpl.filterRequestFirstChunkWithOptionalShortCircuitResponse(mock(RequestInfo.class), mock(ChannelHandlerContext.class)));
    assertThat(firstChunkShortCircuitEx).isNotNull().isInstanceOf(UnsupportedOperationException.class);
    Throwable lastChunkShortCircuitEx = catchThrowable(() -> defaultImpl.filterRequestLastChunkWithOptionalShortCircuitResponse(mock(RequestInfo.class), mock(ChannelHandlerContext.class)));
    assertThat(lastChunkShortCircuitEx).isNotNull().isInstanceOf(UnsupportedOperationException.class);
    assertThat(defaultImpl.shouldExecuteBeforeSecurityValidation()).isTrue();
}

Example 4 with ResponseInfo

use of com.nike.riposte.server.http.ResponseInfo in project riposte by Nike-Inc.

the class ShortCircuitingRequestAndResponseFilterTest method default_method_implementations_behave_as_expected.

@Test
public void default_method_implementations_behave_as_expected() {
    // given
    ShortCircuitingRequestAndResponseFilter defaultImpl = new ShortCircuitingRequestAndResponseFilter() {

        @Override
        @Nullable
        public <T> ResponseInfo<T> filterResponse(@NotNull ResponseInfo<T> currentResponseInfo, @NotNull RequestInfo<?> requestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }

        @Override
        @Nullable
        public <T> Pair<RequestInfo<T>, Optional<ResponseInfo<?>>> filterRequestFirstChunkWithOptionalShortCircuitResponse(@NotNull RequestInfo<T> currentRequestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }

        @Override
        @Nullable
        public <T> Pair<RequestInfo<T>, Optional<ResponseInfo<?>>> filterRequestLastChunkWithOptionalShortCircuitResponse(@NotNull RequestInfo<T> currentRequestInfo, @NotNull ChannelHandlerContext ctx) {
            return null;
        }
    };
    // expect
    assertThat(defaultImpl.isShortCircuitRequestFilter()).isTrue();
    Throwable firstChunkEx = catchThrowable(() -> defaultImpl.filterRequestFirstChunkNoPayload(mock(RequestInfo.class), mock(ChannelHandlerContext.class)));
    assertThat(firstChunkEx).isNotNull().isInstanceOf(UnsupportedOperationException.class);
    Throwable lastChunkEx = catchThrowable(() -> defaultImpl.filterRequestLastChunkWithFullPayload(mock(RequestInfo.class), mock(ChannelHandlerContext.class)));
    assertThat(lastChunkEx).isNotNull().isInstanceOf(UnsupportedOperationException.class);
}

Example 5 with ResponseInfo

use of com.nike.riposte.server.http.ResponseInfo in project riposte by Nike-Inc.

the class ExceptionHandlingHandlerTest method processUnhandledError_uses_getRequestInfo_and_calls_riposteUnhandledErrorHandler_and_returns_value_of_setupResponseInfoBasedOnErrorResponseInfo.

@Test
public void processUnhandledError_uses_getRequestInfo_and_calls_riposteUnhandledErrorHandler_and_returns_value_of_setupResponseInfoBasedOnErrorResponseInfo() throws JsonProcessingException, UnexpectedMajorErrorHandlingError {
    // given
    HttpProcessingState stateMock = mock(HttpProcessingState.class);
    Object msg = new Object();
    Throwable cause = new Exception();
    ExceptionHandlingHandler handlerSpy = spy(handler);
    RequestInfo<?> requestInfoMock = mock(RequestInfo.class);
    ErrorResponseInfo errorResponseInfoMock = mock(ErrorResponseInfo.class);
    doReturn(requestInfoMock).when(handlerSpy).getRequestInfo(stateMock, msg);
    doReturn(errorResponseInfoMock).when(riposteUnhandledErrorHandlerMock).handleError(cause, requestInfoMock);
    // when
    ResponseInfo<ErrorResponseBody> response = handlerSpy.processUnhandledError(stateMock, msg, cause);
    // then
    verify(handlerSpy).getRequestInfo(stateMock, msg);
    verify(riposteUnhandledErrorHandlerMock).handleError(cause, requestInfoMock);
    ArgumentCaptor<ResponseInfo> responseInfoArgumentCaptor = ArgumentCaptor.forClass(ResponseInfo.class);
    verify(handlerSpy).setupResponseInfoBasedOnErrorResponseInfo(responseInfoArgumentCaptor.capture(), eq(errorResponseInfoMock));
    ResponseInfo<ErrorResponseBody> responseInfoPassedIntoSetupMethod = responseInfoArgumentCaptor.getValue();
    assertThat(response, is(responseInfoPassedIntoSetupMethod));
}