Examples with ExceptionHandlingHandler com.nike.riposte.server.handler.ExceptionHandlingHandler used on opensource projects

Example 1 with ExceptionHandlingHandler

use of com.nike.riposte.server.handler.ExceptionHandlingHandler in project riposte by Nike-Inc.

the class HttpChannelInitializerTest method initChannel_adds_ExceptionHandlingHandler_immediately_before_ResponseSenderHandler_and_after_NonblockingEndpointExecutionHandler_and_uses_riposteErrorHandler_and_riposteUnhandledErrorHandler.

@Test
public void initChannel_adds_ExceptionHandlingHandler_immediately_before_ResponseSenderHandler_and_after_NonblockingEndpointExecutionHandler_and_uses_riposteErrorHandler_and_riposteUnhandledErrorHandler() {
    // given
    HttpChannelInitializer hci = basicHttpChannelInitializerNoUtilityHandlers();
    RiposteErrorHandler expectedRiposteErrorHandler = extractField(hci, "riposteErrorHandler");
    RiposteUnhandledErrorHandler expectedRiposteUnhandledErrorHandler = extractField(hci, "riposteUnhandledErrorHandler");
    // when
    hci.initChannel(socketChannelMock);
    // then
    ArgumentCaptor<ChannelHandler> channelHandlerArgumentCaptor = ArgumentCaptor.forClass(ChannelHandler.class);
    verify(channelPipelineMock, atLeastOnce()).addLast(anyString(), channelHandlerArgumentCaptor.capture());
    List<ChannelHandler> handlers = channelHandlerArgumentCaptor.getAllValues();
    Pair<Integer, ResponseSenderHandler> responseSenderHandler = findChannelHandler(handlers, ResponseSenderHandler.class);
    Pair<Integer, NonblockingEndpointExecutionHandler> nonblockingEndpointExecutionHandler = findChannelHandler(handlers, NonblockingEndpointExecutionHandler.class);
    Pair<Integer, ExceptionHandlingHandler> exceptionHandlingHandler = findChannelHandler(handlers, ExceptionHandlingHandler.class);
    assertThat(responseSenderHandler, notNullValue());
    assertThat(nonblockingEndpointExecutionHandler, notNullValue());
    assertThat(exceptionHandlingHandler, notNullValue());
    assertThat(exceptionHandlingHandler.getLeft(), is(responseSenderHandler.getLeft() - 1));
    assertThat(exceptionHandlingHandler.getLeft(), is(greaterThan(nonblockingEndpointExecutionHandler.getLeft())));
    // and then
    RiposteErrorHandler actualRiposteErrorHandler = (RiposteErrorHandler) Whitebox.getInternalState(exceptionHandlingHandler.getRight(), "riposteErrorHandler");
    RiposteUnhandledErrorHandler actualRiposteUnhandledErrorHandler = (RiposteUnhandledErrorHandler) Whitebox.getInternalState(exceptionHandlingHandler.getRight(), "riposteUnhandledErrorHandler");
    assertThat(actualRiposteErrorHandler, is(expectedRiposteErrorHandler));
    assertThat(actualRiposteUnhandledErrorHandler, is(expectedRiposteUnhandledErrorHandler));
}

Example 2 with ExceptionHandlingHandler

use of com.nike.riposte.server.handler.ExceptionHandlingHandler in project riposte by Nike-Inc.

the class HttpChannelInitializerTest method initChannel_adds_ResponseFilterHandler_after_ExceptionHandlingHandler_and_before_ResponseSenderHandler_and_uses_cached_handler.

@Test
public void initChannel_adds_ResponseFilterHandler_after_ExceptionHandlingHandler_and_before_ResponseSenderHandler_and_uses_cached_handler() {
    // given
    HttpChannelInitializer hci = basicHttpChannelInitializer(null, 0, 42, false, null, createRequestAndResponseFilterMock());
    // when
    hci.initChannel(socketChannelMock);
    // then
    ArgumentCaptor<ChannelHandler> channelHandlerArgumentCaptor = ArgumentCaptor.forClass(ChannelHandler.class);
    verify(channelPipelineMock, atLeastOnce()).addLast(anyString(), channelHandlerArgumentCaptor.capture());
    List<ChannelHandler> handlers = channelHandlerArgumentCaptor.getAllValues();
    Pair<Integer, ExceptionHandlingHandler> exceptionHandler = findChannelHandler(handlers, ExceptionHandlingHandler.class);
    Pair<Integer, ResponseFilterHandler> responseFilterHandler = findChannelHandler(handlers, ResponseFilterHandler.class);
    Pair<Integer, ResponseSenderHandler> responseSenderHandler = findChannelHandler(handlers, ResponseSenderHandler.class);
    assertThat(exceptionHandler, notNullValue());
    assertThat(responseFilterHandler, notNullValue());
    assertThat(responseSenderHandler, notNullValue());
    Assertions.assertThat(responseFilterHandler.getLeft()).isGreaterThan(exceptionHandler.getLeft());
    Assertions.assertThat(responseFilterHandler.getLeft()).isLessThan(responseSenderHandler.getLeft());
    // and then
    ResponseFilterHandler cachedHandler = extractField(hci, "cachedResponseFilterHandler");
    Assertions.assertThat(responseFilterHandler.getRight()).isSameAs(cachedHandler);
}

Example 3 with ExceptionHandlingHandler

use of com.nike.riposte.server.handler.ExceptionHandlingHandler in project riposte by Nike-Inc.

the class HttpChannelInitializerTest method initChannel_adds_ChannelPipelineFinalizerHandler_as_the_last_handler_and_uses_the_ExceptionHandlingHandler_handler_and_responseSender_and_metricsListener.

@Test
public void initChannel_adds_ChannelPipelineFinalizerHandler_as_the_last_handler_and_uses_the_ExceptionHandlingHandler_handler_and_responseSender_and_metricsListener() {
    // given
    HttpChannelInitializer hci = basicHttpChannelInitializerNoUtilityHandlers();
    MetricsListener expectedMetricsListener = mock(MetricsListener.class);
    Whitebox.setInternalState(hci, "metricsListener", expectedMetricsListener);
    ResponseSender expectedResponseSender = extractField(hci, "responseSender");
    // when
    hci.initChannel(socketChannelMock);
    // then
    ArgumentCaptor<ChannelHandler> channelHandlerArgumentCaptor = ArgumentCaptor.forClass(ChannelHandler.class);
    verify(channelPipelineMock, atLeastOnce()).addLast(anyString(), channelHandlerArgumentCaptor.capture());
    List<ChannelHandler> handlers = channelHandlerArgumentCaptor.getAllValues();
    Pair<Integer, ChannelPipelineFinalizerHandler> channelPipelineFinalizerHandler = findChannelHandler(handlers, ChannelPipelineFinalizerHandler.class);
    assertThat(channelPipelineFinalizerHandler, notNullValue());
    assertThat(channelPipelineFinalizerHandler.getLeft(), is(handlers.size() - 1));
    // and then
    Pair<Integer, ExceptionHandlingHandler> expectedExceptionHandlingHandlerPair = findChannelHandler(handlers, ExceptionHandlingHandler.class);
    assertThat(expectedExceptionHandlingHandlerPair, notNullValue());
    ExceptionHandlingHandler actualExceptionHandlingHandler = (ExceptionHandlingHandler) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "exceptionHandlingHandler");
    ResponseSender actualResponseSender = (ResponseSender) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "responseSender");
    MetricsListener actualMetricsListener = (MetricsListener) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "metricsListener");
    assertThat(actualExceptionHandlingHandler, is(expectedExceptionHandlingHandlerPair.getRight()));
    assertThat(actualResponseSender, is(expectedResponseSender));
    assertThat(actualMetricsListener, is(expectedMetricsListener));
}

Example 4 with ExceptionHandlingHandler

use of com.nike.riposte.server.handler.ExceptionHandlingHandler in project riposte by Nike-Inc.

the class HttpChannelInitializerTest method initChannel_adds_ChannelPipelineFinalizerHandler_as_the_last_handler_and_passes_the_expected_args.

@Test
public void initChannel_adds_ChannelPipelineFinalizerHandler_as_the_last_handler_and_passes_the_expected_args() {
    // given
    HttpChannelInitializer hci = basicHttpChannelInitializerNoUtilityHandlers();
    MetricsListener expectedMetricsListener = mock(MetricsListener.class);
    AccessLogger expectedAccessLogger = mock(AccessLogger.class);
    Whitebox.setInternalState(hci, "metricsListener", expectedMetricsListener);
    Whitebox.setInternalState(hci, "accessLogger", expectedAccessLogger);
    ResponseSender expectedResponseSender = extractField(hci, "responseSender");
    // when
    hci.initChannel(socketChannelMock);
    // then
    ArgumentCaptor<ChannelHandler> channelHandlerArgumentCaptor = ArgumentCaptor.forClass(ChannelHandler.class);
    verify(channelPipelineMock, atLeastOnce()).addLast(anyString(), channelHandlerArgumentCaptor.capture());
    List<ChannelHandler> handlers = channelHandlerArgumentCaptor.getAllValues();
    Pair<Integer, ChannelPipelineFinalizerHandler> channelPipelineFinalizerHandler = findChannelHandler(handlers, ChannelPipelineFinalizerHandler.class);
    assertThat(channelPipelineFinalizerHandler, notNullValue());
    assertThat(channelPipelineFinalizerHandler.getLeft(), is(handlers.size() - 1));
    // and then
    Pair<Integer, ExceptionHandlingHandler> expectedExceptionHandlingHandlerPair = findChannelHandler(handlers, ExceptionHandlingHandler.class);
    assertThat(expectedExceptionHandlingHandlerPair, notNullValue());
    ExceptionHandlingHandler actualExceptionHandlingHandler = (ExceptionHandlingHandler) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "exceptionHandlingHandler");
    ResponseSender actualResponseSender = (ResponseSender) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "responseSender");
    MetricsListener actualMetricsListener = (MetricsListener) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "metricsListener");
    AccessLogger actualAccessLogger = (AccessLogger) Whitebox.getInternalState(channelPipelineFinalizerHandler.getRight(), "accessLogger");
    assertThat(actualExceptionHandlingHandler, is(expectedExceptionHandlingHandlerPair.getRight()));
    assertThat(actualResponseSender, is(expectedResponseSender));
    assertThat(actualMetricsListener, is(expectedMetricsListener));
    Assertions.assertThat(actualAccessLogger).isSameAs(expectedAccessLogger);
}

Example 5 with ExceptionHandlingHandler

use of com.nike.riposte.server.handler.ExceptionHandlingHandler in project riposte by Nike-Inc.

the class HttpChannelInitializer method initChannel.

@Override
public void initChannel(SocketChannel ch) {
    ChannelPipeline p = ch.pipeline();
    // request/response payloads, etc.
    if (debugChannelLifecycleLoggingEnabled) {
        p.addLast(SERVER_WORKER_CHANNEL_DEBUG_LOGGING_HANDLER_NAME, new LoggingHandler(SERVER_WORKER_CHANNEL_DEBUG_SLF4J_LOGGER_NAME, LogLevel.DEBUG));
    }
    // order).
    if (sslCtx != null)
        p.addLast(SSL_HANDLER_NAME, sslCtx.newHandler(ch.alloc()));
    // OUTBOUND - Add HttpResponseEncoder to encode our responses appropriately.
    // This MUST be the earliest "outbound" handler after the SSL handler since outbound handlers are
    // processed in reverse order.
    p.addLast(HTTP_RESPONSE_ENCODER_HANDLER_NAME, new HttpResponseEncoder());
    // OUTBOUND - Add ProcessFinalResponseOutputHandler to get the final response headers, calculate the final
    // content length (after compression/gzip and/or any other modifications), etc, and set those values
    // on the channel's HttpProcessingState.
    p.addLast(PROCESS_FINAL_RESPONSE_OUTPUT_HANDLER_NAME, new ProcessFinalResponseOutputHandler());
    // INBOUND - Add HttpRequestDecoder so that incoming messages are translated into the appropriate HttpMessage
    // objects.
    p.addLast(HTTP_REQUEST_DECODER_HANDLER_NAME, new HttpRequestDecoder(httpRequestDecoderConfig.maxInitialLineLength(), httpRequestDecoderConfig.maxHeaderSize(), httpRequestDecoderConfig.maxChunkSize()));
    // INBOUND - Now that the message is translated into HttpMessages we can add RequestStateCleanerHandler to
    // setup/clean state for the rest of the pipeline.
    p.addLast(REQUEST_STATE_CLEANER_HANDLER_NAME, new RequestStateCleanerHandler(metricsListener, incompleteHttpCallTimeoutMillis));
    // INBOUND - Add DTraceStartHandler to start the distributed tracing for this request
    p.addLast(DTRACE_START_HANDLER_NAME, new DTraceStartHandler(userIdHeaderKeys));
    // INBOUND - Access log start
    p.addLast(ACCESS_LOG_START_HANDLER_NAME, new AccessLogStartHandler());
    // IN/OUT - Add SmartHttpContentCompressor for automatic content compression (if appropriate for the
    // request/response/size threshold). This must be after HttpRequestDecoder on the incoming pipeline and
    // before HttpResponseEncoder on the outbound pipeline (keep in mind that "before" on outbound means
    // later in the list since outbound is processed in reverse order).
    p.addLast(SMART_HTTP_CONTENT_COMPRESSOR_HANDLER_NAME, new SmartHttpContentCompressor(responseCompressionThresholdBytes));
    // before RoutingHandler throws 404s/405s.
    if (beforeSecurityRequestFilterHandler != null)
        p.addLast(REQUEST_FILTER_BEFORE_SECURITY_HANDLER_NAME, beforeSecurityRequestFilterHandler);
    // INBOUND - Add RoutingHandler to figure out which endpoint should handle the request and set it on our request
    // state for later execution
    p.addLast(ROUTING_HANDLER_NAME, new RoutingHandler(endpoints, maxRequestSizeInBytes));
    // INBOUND - Add SmartHttpContentDecompressor for automatic content decompression if the request indicates it
    // is compressed *and* the target endpoint (determined by the previous RoutingHandler) is one that
    // is eligible for auto-decompression.
    p.addLast(SMART_HTTP_CONTENT_DECOMPRESSOR_HANDLER_NAME, new SmartHttpContentDecompressor());
    // INBOUND - Add RequestInfoSetterHandler to populate our RequestInfo's content.
    p.addLast(REQUEST_INFO_SETTER_HANDLER_NAME, new RequestInfoSetterHandler(maxRequestSizeInBytes));
    // maxOpenChannelsThreshold is not -1.
    if (maxOpenChannelsThreshold != -1) {
        p.addLast(OPEN_CHANNEL_LIMIT_HANDLER_NAME, new OpenChannelLimitHandler(openChannelsGroup, maxOpenChannelsThreshold));
    }
    // INBOUND - Add SecurityValidationHandler to validate the RequestInfo object for the matching endpoint
    p.addLast(SECURITY_VALIDATION_HANDLER_NAME, new SecurityValidationHandler(requestSecurityValidator));
    // INBOUND - Add the RequestFilterHandler for after security (if we have any filters to apply).
    if (afterSecurityRequestFilterHandler != null)
        p.addLast(REQUEST_FILTER_AFTER_SECURITY_HANDLER_NAME, afterSecurityRequestFilterHandler);
    // INBOUND - Now that the request state knows which endpoint will be called we can try to deserialize the
    // request content (if desired by the endpoint)
    p.addLast(REQUEST_CONTENT_DESERIALIZER_HANDLER_NAME, new RequestContentDeserializerHandler(requestContentDeserializer));
    // deserialized content (if desired by the endpoint and if we have a non-null validator)
    if (validationService != null)
        p.addLast(REQUEST_CONTENT_VALIDATION_HANDLER_NAME, new RequestContentValidationHandler(validationService));
    // INBOUND - Add NonblockingEndpointExecutionHandler to perform execution of async/nonblocking endpoints
    p.addLast(NONBLOCKING_ENDPOINT_EXECUTION_HANDLER_NAME, new NonblockingEndpointExecutionHandler(longRunningTaskExecutor, defaultCompletableFutureTimeoutMillis));
    // INBOUND - Add ProxyRouterEndpointExecutionHandler to perform execution of proxy routing endpoints
    p.addLast(PROXY_ROUTER_ENDPOINT_EXECUTION_HANDLER_NAME, new ProxyRouterEndpointExecutionHandler(longRunningTaskExecutor, streamingAsyncHttpClientForProxyRouterEndpoints, defaultCompletableFutureTimeoutMillis));
    // INBOUND - Add RequestHasBeenHandledVerificationHandler to verify that one of the endpoint handlers took care
    // of the request. This makes sure that the messages coming into channelRead are correctly typed for
    // the rest of the pipeline.
    p.addLast(REQUEST_HAS_BEEN_HANDLED_VERIFICATION_HANDLER_NAME, new RequestHasBeenHandledVerificationHandler());
    // INBOUND - Add ExceptionHandlingHandler to catch and deal with any exceptions or requests that fell through
    // the cracks.
    ExceptionHandlingHandler exceptionHandlingHandler = new ExceptionHandlingHandler(riposteErrorHandler, riposteUnhandledErrorHandler);
    p.addLast(EXCEPTION_HANDLING_HANDLER_NAME, exceptionHandlingHandler);
    // INBOUND - Add the ResponseFilterHandler (if we have any filters to apply).
    if (cachedResponseFilterHandler != null)
        p.addLast(RESPONSE_FILTER_HANDLER_NAME, cachedResponseFilterHandler);
    // INBOUND - Add ResponseSenderHandler to send the response that got put into the request state
    p.addLast(RESPONSE_SENDER_HANDLER_NAME, new ResponseSenderHandler(responseSender));
    // INBOUND - Access log end
    p.addLast(ACCESS_LOG_END_HANDLER_NAME, new AccessLogEndHandler(accessLogger));
    // INBOUND - Add DTraceEndHandler to finish up our distributed trace for this request.
    p.addLast(DTRACE_END_HANDLER_NAME, new DTraceEndHandler());
    // INBOUND - Add ChannelPipelineFinalizerHandler to stop the request processing.
    p.addLast(CHANNEL_PIPELINE_FINALIZER_HANDLER_NAME, new ChannelPipelineFinalizerHandler(exceptionHandlingHandler, responseSender, metricsListener, accessLogger, workerChannelIdleTimeoutMillis));
    // pipeline create hooks
    if (pipelineCreateHooks != null) {
        for (PipelineCreateHook hook : pipelineCreateHooks) {
            hook.executePipelineCreateHook(p);
        }
    }
}