Fix header size exceeded error (#1967)

Co-authored-by: alaborda <[email protected]>

Author: lalernehl

zuul-core/src/main/java/com/netflix/zuul/exception/OutboundErrorType.java

@@ -64,6 +64,7 @@ public enum OutboundErrorType implements ErrorType {
             ERROR_TYPE_ORIGIN_CONCURRENCY_EXCEEDED_STATUS.get(),
             ZuulStatusCategory.FAILURE_LOCAL_THROTTLED_ORIGIN_CONCURRENCY,
             ClientException.ErrorType.SERVER_THROTTLED),
+    HEADER_FIELDS_TOO_LARGE(431, ZuulStatusCategory.FAILURE_LOCAL_HEADER_FIELDS_TOO_LARGE, ClientException.ErrorType.GENERAL),
     OTHER(ERROR_TYPE_OTHER_STATUS.get(), ZuulStatusCategory.FAILURE_LOCAL, ClientException.ErrorType.GENERAL);
 
     private static final String NAME_PREFIX = "ORIGIN_";

zuul-core/src/main/java/com/netflix/zuul/netty/NettyRequestAttemptFactory.java

@@ -24,6 +24,7 @@
 import com.netflix.zuul.niws.RequestAttempts;
 import com.netflix.zuul.origins.OriginConcurrencyExceededException;
 import io.netty.channel.unix.Errors;
+import io.netty.handler.codec.http2.Http2Exception.HeaderListSizeException;
 import io.netty.handler.timeout.ReadTimeoutException;
 import java.nio.channels.ClosedChannelException;
 import org.slf4j.Logger;
@@ -62,6 +63,10 @@ public ErrorType mapNettyToOutboundErrorType(Throwable t) {
             return OutboundErrorType.RESET_CONNECTION;
         }
 
+        if (t instanceof HeaderListSizeException) {
+            return OutboundErrorType.HEADER_FIELDS_TOO_LARGE;
+        }
+
         Throwable cause = t.getCause();
         if (cause instanceof IllegalStateException && cause.getMessage().contains("server")) {
             LOG.warn("IllegalStateException mapped to NO_AVAILABLE_SERVERS", cause);

zuul-core/src/main/java/com/netflix/zuul/stats/status/ZuulStatusCategory.java

@@ -60,7 +60,7 @@ public enum ZuulStatusCategory implements StatusCategory {
     FAILURE_LOCAL_THROTTLED_ORIGIN_CONCURRENCY(
             ZuulStatusCategoryGroup.FAILURE, 8, "Throttled due to reaching concurrency limit to origin"),
     FAILURE_LOCAL_IDLE_TIMEOUT(ZuulStatusCategoryGroup.FAILURE, 9, "Idle timeout due to channel inactivity"),
-
+    FAILURE_LOCAL_HEADER_FIELDS_TOO_LARGE(ZuulStatusCategoryGroup.FAILURE, 5, "Header Fields Too Large"),
     FAILURE_CLIENT_BAD_REQUEST(ZuulStatusCategoryGroup.FAILURE, 12, "Invalid request provided"),
     FAILURE_CLIENT_CANCELLED(ZuulStatusCategoryGroup.FAILURE, 13, "Client abandoned/closed the connection"),
     FAILURE_CLIENT_PIPELINE_REJECT(ZuulStatusCategoryGroup.FAILURE, 17, "Client rejected due to HTTP Pipelining"),

zuul-core/src/test/java/com/netflix/zuul/netty/NettyRequestAttemptFactoryTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2018 Netflix, Inc.
+ *
+ *      Licensed under the Apache License, Version 2.0 (the "License");
+ *      you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *          http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *      Unless required by applicable law or agreed to in writing, software
+ *      distributed under the License is distributed on an "AS IS" BASIS,
+ *      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *      See the License for the specific language governing permissions and
+ *      limitations under the License.
+ */
+
+package com.netflix.zuul.netty;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import com.netflix.zuul.context.SessionContext;
+import com.netflix.zuul.exception.OutboundErrorType;
+import com.netflix.zuul.exception.OutboundException;
+import com.netflix.zuul.netty.connectionpool.OriginConnectException;
+import com.netflix.zuul.niws.RequestAttempts;
+import com.netflix.zuul.origins.OriginConcurrencyExceededException;
+import com.netflix.zuul.origins.OriginName;
+import io.netty.handler.codec.http2.Http2Error;
+import io.netty.handler.codec.http2.Http2Exception;
+import io.netty.handler.timeout.ReadTimeoutException;
+import java.nio.channels.ClosedChannelException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class NettyRequestAttemptFactoryTest {
+    private NettyRequestAttemptFactory factory;
+
+    @BeforeEach
+    public void setup() {
+        factory = new NettyRequestAttemptFactory();
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToOutboundException() {
+        Exception e = new OutboundException(OutboundErrorType.OTHER,
+                new RequestAttempts());
+        OutboundException mapException = factory.mapNettyToOutboundException(e, new SessionContext());
+
+        assertEquals(e, mapException);
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToReadTimeoutException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new ReadTimeoutException(), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.READ_TIMEOUT, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToOriginConcurrencyExceededException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new OriginConcurrencyExceededException(OriginName.fromVipAndApp("vip", "app")), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.ORIGIN_CONCURRENCY_EXCEEDED, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToOriginConnectException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new OriginConnectException("error",
+                OutboundErrorType.OTHER), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.OTHER, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToClosedChannelException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new ClosedChannelException(), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.RESET_CONNECTION, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToHeaderListSizeException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(Http2Exception.headerListSizeError(1, Http2Error.CONNECT_ERROR, false, ""), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.HEADER_FIELDS_TOO_LARGE, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToIllegalStateException() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new Exception(new IllegalStateException(new Throwable("No available server"))), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.NO_AVAILABLE_SERVERS, mapException.getOutboundErrorType());
+    }
+
+    @Test
+    public void mapNettyToOutboundExceptionMapsToOtherExceptionType() {
+        OutboundException mapException = factory.mapNettyToOutboundException(new Exception(), new SessionContext());
+
+        // check that the type is OutboundException
+        assertNotNull(mapException);
+        assertEquals(OutboundErrorType.OTHER, mapException.getOutboundErrorType());
+    }
+}