\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *
\n * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on\n * an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations under the License.\n */\npackage com.netflix.netty.common;\n\nimport com.netflix.spectator.api.Counter;\nimport com.netflix.spectator.api.Registry;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.handler.timeout.IdleStateEvent;\n\n/**\n * Just listens for the IdleStateEvent and closes the channel if received.\n */\npublic class CloseOnIdleStateHandler extends ChannelInboundHandlerAdapter {\n\n private final Counter counter;\n\n public CloseOnIdleStateHandler(Registry registry, String metricId) {\n this.counter = registry.counter(\"server.connections.idle.timeout\", \"id\", metricId);\n }\n\n @Override\n public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {\n super.userEventTriggered(ctx, evt);\n\n if (evt instanceof IdleStateEvent) {\n counter.increment();\n ctx.close();\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/ConnectionCloseChannelAttributes.java",
"content": "/*\n * Copyright 2019 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.netty.common.channel.config.ChannelConfig;\nimport com.netflix.netty.common.channel.config.CommonChannelConfigKeys;\nimport com.netflix.zuul.netty.server.BaseZuulChannelInitializer;\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.util.AttributeKey;\n\npublic class ConnectionCloseChannelAttributes {\n public static final AttributeKey CLOSE_AFTER_RESPONSE =\n AttributeKey.newInstance(\"CLOSE_AFTER_RESPONSE\");\n public static final AttributeKey CLOSE_TYPE = AttributeKey.newInstance(\"CLOSE_TYPE\");\n\n public static int gracefulCloseDelay(Channel channel) {\n ChannelConfig channelConfig =\n channel.attr(BaseZuulChannelInitializer.ATTR_CHANNEL_CONFIG).get();\n Integer gracefulCloseDelay = channelConfig.get(CommonChannelConfigKeys.connCloseDelay);\n return gracefulCloseDelay == null ? 0 : gracefulCloseDelay;\n }\n\n public static boolean allowGracefulDelayed(Channel channel) {\n ChannelConfig channelConfig =\n channel.attr(BaseZuulChannelInitializer.ATTR_CHANNEL_CONFIG).get();\n Boolean value = channelConfig.get(CommonChannelConfigKeys.http2AllowGracefulDelayed);\n return value == null ? false : value;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/ConnectionCloseType.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.channel.Channel;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 2:04 PM\n */\npublic enum ConnectionCloseType {\n IMMEDIATE,\n GRACEFUL,\n DELAYED_GRACEFUL;\n\n public static ConnectionCloseType fromChannel(Channel ch) {\n ConnectionCloseType type =\n ch.attr(ConnectionCloseChannelAttributes.CLOSE_TYPE).get();\n if (type == null) {\n // Default to immediate.\n type = ConnectionCloseType.IMMEDIATE;\n }\n return type;\n }\n\n public static void setForChannel(Channel ch, ConnectionCloseType type) {\n ch.attr(ConnectionCloseChannelAttributes.CLOSE_TYPE).set(type);\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/Http1ConnectionCloseHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelDuplexHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.handler.codec.http.HttpHeaderNames;\nimport io.netty.handler.codec.http.HttpResponse;\nimport io.netty.handler.codec.http.LastHttpContent;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.atomic.AtomicBoolean;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 2:03 PM\n */\npublic class Http1ConnectionCloseHandler extends ChannelDuplexHandler {\n private static final Logger LOG = LoggerFactory.getLogger(Http1ConnectionCloseHandler.class);\n\n private final AtomicBoolean requestInflight = new AtomicBoolean(Boolean.FALSE);\n\n @Override\n public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {\n ChannelPromise closePromise = ctx.channel()\n .attr(ConnectionCloseChannelAttributes.CLOSE_AFTER_RESPONSE)\n .get();\n\n if (msg instanceof HttpResponse response && closePromise != null) {\n // Add header to tell client that they should close this connection.\n response.headers().set(HttpHeaderNames.CONNECTION, \"close\");\n }\n\n super.write(ctx, msg, promise);\n\n // Close the connection immediately after LastContent is written, rather than\n // waiting until the graceful-delay is up if this flag is set.\n if (msg instanceof LastHttpContent) {\n if (closePromise != null) {\n promise.addListener(future -> {\n ConnectionCloseType type = ConnectionCloseType.fromChannel(ctx.channel());\n closeChannel(ctx, type, closePromise);\n });\n }\n }\n }\n\n @Override\n public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {\n // Track when there's an inflight request.\n if (evt instanceof HttpLifecycleChannelHandler.StartEvent) {\n requestInflight.set(Boolean.TRUE);\n } else if (evt instanceof HttpLifecycleChannelHandler.CompleteEvent) {\n requestInflight.set(Boolean.FALSE);\n }\n\n super.userEventTriggered(ctx, evt);\n }\n\n protected void closeChannel(ChannelHandlerContext ctx, ConnectionCloseType evt, ChannelPromise promise) {\n switch (evt) {\n case DELAYED_GRACEFUL:\n gracefully(ctx, promise);\n break;\n case GRACEFUL:\n gracefully(ctx, promise);\n break;\n case IMMEDIATE:\n immediately(ctx, promise);\n break;\n default:\n throw new IllegalArgumentException(\"Unknown ConnectionCloseEvent type! - \" + String.valueOf(evt));\n }\n }\n\n protected void gracefully(ChannelHandlerContext ctx, ChannelPromise promise) {\n Channel channel = ctx.channel();\n if (channel.isActive()) {\n String channelId = channel.id().asShortText();\n\n // In gracefulCloseDelay secs time, go ahead and close the connection if it hasn't already been.\n int gracefulCloseDelay = ConnectionCloseChannelAttributes.gracefulCloseDelay(channel);\n ctx.executor()\n .schedule(\n () -> {\n\n // Check that the client hasn't already closed the connection.\n if (channel.isActive()) {\n\n // If there is still an inflight request, then don't close the conn now. Instead\n // assume that it will be closed\n // either after the response finally gets written (due to us having set the\n // CLOSE_AFTER_RESPONSE flag), or when the IdleTimeout\n // for this conn fires.\n if (requestInflight.get()) {\n LOG.debug(\n \"gracefully: firing graceful_shutdown event to close connection, but\"\n + \" request still inflight, so leaving. channel={}\",\n channelId);\n } else {\n LOG.debug(\n \"gracefully: firing graceful_shutdown event to close connection.\"\n + \" channel={}\",\n channelId);\n ctx.close(promise);\n }\n } else {\n LOG.debug(\"gracefully: connection already closed. channel={}\", channelId);\n promise.setSuccess();\n }\n },\n gracefulCloseDelay,\n TimeUnit.SECONDS);\n } else {\n promise.setSuccess();\n }\n }\n\n protected void immediately(ChannelHandlerContext ctx, ChannelPromise promise) {\n if (ctx.channel().isActive()) {\n ctx.close(promise);\n } else {\n promise.setSuccess();\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/Http1ConnectionExpiryHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.handler.codec.http.HttpResponse;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 9:58 AM\n */\npublic class Http1ConnectionExpiryHandler extends AbstrHttpConnectionExpiryHandler {\n public Http1ConnectionExpiryHandler(int maxRequests, int maxRequestsUnderBrownout, int maxExpiry) {\n super(ConnectionCloseType.GRACEFUL, maxRequestsUnderBrownout, maxRequests, maxExpiry);\n }\n\n @Override\n protected boolean isResponseHeaders(Object msg) {\n return msg instanceof HttpResponse;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/Http2ConnectionCloseHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.spectator.api.Id;\nimport com.netflix.spectator.api.Registry;\nimport com.netflix.zuul.util.HttpUtils;\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelDuplexHandler;\nimport io.netty.channel.ChannelHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.channel.DelegatingChannelPromiseNotifier;\nimport io.netty.handler.codec.http2.DefaultHttp2GoAwayFrame;\nimport io.netty.handler.codec.http2.Http2DataFrame;\nimport io.netty.handler.codec.http2.Http2Error;\nimport io.netty.handler.codec.http2.Http2Exception;\nimport io.netty.handler.codec.http2.Http2HeadersFrame;\nimport io.netty.util.concurrent.EventExecutor;\nimport jakarta.inject.Inject;\nimport java.util.concurrent.TimeUnit;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 2:03 PM\n */\n@ChannelHandler.Sharable\npublic class Http2ConnectionCloseHandler extends ChannelDuplexHandler {\n private static final Logger LOG = LoggerFactory.getLogger(Http2ConnectionCloseHandler.class);\n\n private final Registry registry;\n private final Id counterBaseId;\n\n @Inject\n public Http2ConnectionCloseHandler(Registry registry) {\n super();\n this.registry = registry;\n this.counterBaseId = registry.createId(\"server.connection.close.handled\");\n }\n\n private void incrementCounter(ConnectionCloseType closeType, int port) {\n registry.counter(counterBaseId\n .withTag(\"close_type\", closeType.name())\n .withTag(\"port\", Integer.toString(port))\n .withTag(\"protocol\", \"http2\"))\n .increment();\n }\n\n @Override\n public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {\n // Close the connection immediately after LastContent is written, rather than\n // waiting until the graceful-delay is up if this flag is set.\n if (isEndOfRequestResponse(msg)) {\n Channel parent = HttpUtils.getMainChannel(ctx);\n ChannelPromise closeAfterPromise = shouldCloseAfter(ctx, parent);\n if (closeAfterPromise != null) {\n\n // Add listener to close the channel AFTER response has been sent.\n promise.addListener(future -> {\n // Close the parent (tcp connection) channel.\n closeChannel(ctx, closeAfterPromise);\n });\n }\n }\n\n super.write(ctx, msg, promise);\n }\n\n /**\n * Look on both the stream channel, and the parent channel to see if the CLOSE_AFTER_RESPONSE flag has been set.\n * If so, return that promise.\n *\n * @param ctx\n * @param parent\n * @return\n */\n private ChannelPromise shouldCloseAfter(ChannelHandlerContext ctx, Channel parent) {\n ChannelPromise closeAfterPromise = ctx.channel()\n .attr(ConnectionCloseChannelAttributes.CLOSE_AFTER_RESPONSE)\n .get();\n if (closeAfterPromise == null) {\n closeAfterPromise = parent.attr(ConnectionCloseChannelAttributes.CLOSE_AFTER_RESPONSE)\n .get();\n }\n return closeAfterPromise;\n }\n\n private boolean isEndOfRequestResponse(Object msg) {\n if (msg instanceof Http2HeadersFrame) {\n return ((Http2HeadersFrame) msg).isEndStream();\n }\n if (msg instanceof Http2DataFrame) {\n return ((Http2DataFrame) msg).isEndStream();\n }\n return false;\n }\n\n private void closeChannel(ChannelHandlerContext ctx, ChannelPromise promise) {\n Channel child = ctx.channel();\n Channel parent = HttpUtils.getMainChannel(ctx);\n\n // 1. Check if already_closing flag on this stream channel. If there is, then success this promise and return.\n // If not, then add already_closing flag to this stream channel.\n // 2. Check if already_closing flag on the parent channel.\n // If so, then just return.\n // If not, then set already_closing on parent channel, and then allow through.\n\n if (isAlreadyClosing(child)) {\n promise.setSuccess();\n return;\n }\n\n if (isAlreadyClosing(parent)) {\n return;\n }\n\n // Close according to the specified close type.\n ConnectionCloseType closeType = ConnectionCloseType.fromChannel(parent);\n Integer port =\n parent.attr(SourceAddressChannelHandler.ATTR_SERVER_LOCAL_PORT).get();\n port = port == null ? -1 : port;\n incrementCounter(closeType, port);\n switch (closeType) {\n case DELAYED_GRACEFUL:\n gracefullyWithDelay(ctx.executor(), parent, promise);\n break;\n case GRACEFUL:\n case IMMEDIATE:\n immediate(parent, promise);\n break;\n default:\n throw new IllegalArgumentException(\"Unknown ConnectionCloseEvent type! - \" + closeType);\n }\n }\n\n /**\n * WARNING: Found the OkHttp client gets confused by this behaviour (it ends up putting itself in a bad shutdown state\n * after receiving the first goaway frame, and then dropping any inflight responses but also timing out waiting for them).\n *\n * And worried that other http/2 stacks may be similar, so for now we should NOT use this.\n *\n * This is unfortunate, as FTL wanted this, and it is correct according to the spec.\n *\n * See this code in okhttp where it drops response header frame if state is already shutdown:\n * https://github.com/square/okhttp/blob/master/okhttp/src/main/java/okhttp3/internal/http2/Http2Connection.java#L609\n */\n private void gracefullyWithDelay(EventExecutor executor, Channel parent, ChannelPromise promise) {\n // See javadoc for explanation of why this may be disabled.\n boolean allowGracefulDelayed = ConnectionCloseChannelAttributes.allowGracefulDelayed(parent);\n if (!allowGracefulDelayed) {\n immediate(parent, promise);\n return;\n }\n\n if (!parent.isActive()) {\n promise.setSuccess();\n return;\n }\n\n // First send a 'graceful shutdown' GOAWAY frame.\n /*\n \"A server that is attempting to gracefully shut down a connection SHOULD send an initial GOAWAY frame with\n the last stream identifier set to 231-1 and a NO_ERROR code. This signals to the client that a shutdown is\n imminent and that initiating further requests is prohibited.\"\n -- https://http2.github.io/http2-spec/#GOAWAY\n */\n DefaultHttp2GoAwayFrame goaway = new DefaultHttp2GoAwayFrame(Http2Error.NO_ERROR);\n goaway.setExtraStreamIds(Integer.MAX_VALUE);\n parent.writeAndFlush(goaway);\n LOG.debug(\n \"gracefullyWithDelay: flushed initial go_away frame. channel={}\",\n parent.id().asShortText());\n\n // In N secs time, throw an error that causes the http2 codec to send another GOAWAY frame\n // (this time with accurate lastStreamId) and then close the connection.\n int gracefulCloseDelay = ConnectionCloseChannelAttributes.gracefulCloseDelay(parent);\n executor.schedule(\n () -> {\n\n // Check that the client hasn't already closed the connection (due to the earlier goaway we sent).\n if (parent.isActive()) {\n // NOTE - the netty Http2ConnectionHandler specifically does not send another goaway when we\n // call\n // channel.close() if one has already been sent .... so when we want more than one sent, we need\n // to do it\n // explicitly ourselves like this.\n LOG.debug(\n \"gracefullyWithDelay: firing graceful_shutdown event to make netty send a final\"\n + \" go_away frame and then close connection. channel={}\",\n parent.id().asShortText());\n Http2Exception h2e =\n new Http2Exception(Http2Error.NO_ERROR, Http2Exception.ShutdownHint.GRACEFUL_SHUTDOWN);\n parent.pipeline().fireExceptionCaught(h2e);\n\n parent.close().addListener(future -> {\n promise.setSuccess();\n });\n } else {\n promise.setSuccess();\n }\n },\n gracefulCloseDelay,\n TimeUnit.SECONDS);\n }\n\n private void immediate(Channel parent, ChannelPromise promise) {\n if (parent.isActive()) {\n parent.close().addListener(new DelegatingChannelPromiseNotifier(promise));\n } else {\n promise.setSuccess();\n }\n }\n\n protected boolean isAlreadyClosing(Channel parentChannel) {\n // If already closing, then just return.\n // This will happen because close() is called a 2nd time after sending the goaway frame.\n if (HttpChannelFlags.CLOSING.get(parentChannel)) {\n return true;\n } else {\n HttpChannelFlags.CLOSING.set(parentChannel);\n return false;\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/Http2ConnectionExpiryHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.channel.ChannelHandler;\nimport io.netty.handler.codec.http2.Http2HeadersFrame;\n\n/**\n * This needs to be inserted in the pipeline after the Http2 Codex, but before any h2->h1 conversion.\n *\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 9:58 AM\n */\n@ChannelHandler.Sharable\npublic class Http2ConnectionExpiryHandler extends AbstrHttpConnectionExpiryHandler {\n public Http2ConnectionExpiryHandler(int maxRequests, int maxRequestsUnderBrownout, int maxExpiry) {\n super(ConnectionCloseType.DELAYED_GRACEFUL, maxRequestsUnderBrownout, maxRequests, maxExpiry);\n }\n\n @Override\n protected boolean isResponseHeaders(Object msg) {\n return msg instanceof Http2HeadersFrame;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpChannelFlags.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.util.Attribute;\nimport io.netty.util.AttributeKey;\n\n/**\n * User: michaels@netflix.com\n * Date: 7/10/17\n * Time: 4:29 PM\n */\npublic class HttpChannelFlags {\n public static final Flag IN_BROWNOUT = new Flag(\"_brownout\");\n\n public static final Flag CLOSING = new Flag(\"_connection_closing\");\n\n public static class Flag {\n private final AttributeKey attributeKey;\n\n public Flag(String name) {\n attributeKey = AttributeKey.newInstance(name);\n }\n\n public void set(Channel ch) {\n ch.attr(attributeKey).set(Boolean.TRUE);\n }\n\n public void set(ChannelHandlerContext ctx) {\n set(ctx.channel());\n }\n\n public void remove(Channel ch) {\n ch.attr(attributeKey).set(null);\n }\n\n public boolean get(Channel ch) {\n Attribute attr = ch.attr(attributeKey);\n Boolean value = attr.get();\n return (value == null) ? false : value;\n }\n\n public boolean get(ChannelHandlerContext ctx) {\n return get(ctx.channel());\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpClientLifecycleChannelHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport io.netty.channel.ChannelHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.channel.ChannelOutboundHandlerAdapter;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.HttpResponse;\nimport io.netty.handler.codec.http.LastHttpContent;\n\n/**\n * @author michaels\n */\npublic class HttpClientLifecycleChannelHandler extends HttpLifecycleChannelHandler {\n public static final ChannelHandler INBOUND_CHANNEL_HANDLER = new HttpClientLifecycleInboundChannelHandler();\n public static final ChannelHandler OUTBOUND_CHANNEL_HANDLER = new HttpClientLifecycleOutboundChannelHandler();\n\n @ChannelHandler.Sharable\n private static class HttpClientLifecycleInboundChannelHandler extends ChannelInboundHandlerAdapter {\n @Override\n public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\n if (msg instanceof HttpResponse) {\n ctx.channel().attr(ATTR_HTTP_RESP).set((HttpResponse) msg);\n }\n\n try {\n super.channelRead(ctx, msg);\n } finally {\n if (msg instanceof LastHttpContent) {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.SESSION_COMPLETE);\n }\n }\n }\n\n @Override\n public void channelInactive(ChannelHandlerContext ctx) throws Exception {\n try {\n super.channelInactive(ctx);\n } finally {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.INACTIVE);\n }\n }\n }\n\n @ChannelHandler.Sharable\n private static class HttpClientLifecycleOutboundChannelHandler extends ChannelOutboundHandlerAdapter {\n @Override\n public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {\n if (msg instanceof HttpRequest) {\n fireStartEvent(ctx, (HttpRequest) msg);\n }\n\n super.write(ctx, msg, promise);\n }\n\n @Override\n public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.DISCONNECT);\n\n super.disconnect(ctx, promise);\n }\n\n @Override\n public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.DEREGISTER);\n\n super.deregister(ctx, promise);\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {\n super.exceptionCaught(ctx, cause);\n\n fireCompleteEventIfNotAlready(ctx, CompleteReason.EXCEPTION);\n }\n\n @Override\n public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.CLOSE);\n\n super.close(ctx, promise);\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpLifecycleChannelHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.google.common.annotations.VisibleForTesting;\nimport com.netflix.zuul.passport.CurrentPassport;\nimport com.netflix.zuul.passport.PassportState;\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.HttpResponse;\nimport io.netty.util.Attribute;\nimport io.netty.util.AttributeKey;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * User: michaels@netflix.com\n * Date: 5/24/16\n * Time: 4:09 PM\n */\npublic abstract class HttpLifecycleChannelHandler {\n private static final Logger logger = LoggerFactory.getLogger(HttpLifecycleChannelHandler.class);\n\n public static final AttributeKey ATTR_HTTP_REQ = AttributeKey.newInstance(\"_http_request\");\n public static final AttributeKey ATTR_HTTP_RESP = AttributeKey.newInstance(\"_http_response\");\n public static final AttributeKey ATTR_HTTP_PIPELINE_REJECT =\n AttributeKey.newInstance(\"_http_pipeline_reject\");\n\n protected enum State {\n STARTED,\n COMPLETED\n }\n\n @VisibleForTesting\n protected static final AttributeKey ATTR_STATE = AttributeKey.newInstance(\"_httplifecycle_state\");\n\n protected static boolean fireStartEvent(ChannelHandlerContext ctx, HttpRequest request) {\n // Only allow this method to run once per request.\n Channel channel = ctx.channel();\n Attribute attr = channel.attr(ATTR_STATE);\n State state = attr.get();\n\n if (state == State.STARTED) {\n // This could potentially happen if a bad client sends a 2nd request on the same connection\n // without waiting for the response from the first. And we don't support HTTP Pipelining.\n logger.debug(\n \"Received a http request on connection where we already have a request being processed. Closing\"\n + \" the connection now. channel = {}\",\n channel.id().asLongText());\n channel.attr(ATTR_HTTP_PIPELINE_REJECT).set(Boolean.TRUE);\n channel.close();\n return false;\n }\n\n channel.attr(ATTR_STATE).set(State.STARTED);\n channel.attr(ATTR_HTTP_REQ).set(request);\n ctx.pipeline().fireUserEventTriggered(new StartEvent(request));\n\n return true;\n }\n\n protected static boolean fireCompleteEventIfNotAlready(ChannelHandlerContext ctx, CompleteReason reason) {\n // Only allow this method to run once per request.\n Attribute attr = ctx.channel().attr(ATTR_STATE);\n State state = attr.get();\n\n if (state == null || state != State.STARTED) {\n return false;\n }\n\n attr.set(State.COMPLETED);\n\n HttpRequest request = ctx.channel().attr(ATTR_HTTP_REQ).get();\n HttpResponse response = ctx.channel().attr(ATTR_HTTP_RESP).get();\n\n // Cleanup channel attributes.\n ctx.channel().attr(ATTR_HTTP_REQ).set(null);\n ctx.channel().attr(ATTR_HTTP_RESP).set(null);\n\n // Fire the event to whole pipeline.\n ctx.pipeline().fireUserEventTriggered(new CompleteEvent(reason, request, response));\n\n return true;\n }\n\n protected static void addPassportState(ChannelHandlerContext ctx, PassportState state) {\n CurrentPassport passport = CurrentPassport.fromChannel(ctx.channel());\n passport.add(state);\n }\n\n public enum CompleteReason {\n SESSION_COMPLETE,\n INACTIVE,\n // IDLE,\n DISCONNECT,\n DEREGISTER,\n PIPELINE_REJECT,\n EXCEPTION,\n CLOSE\n // FAILURE_CLIENT_CANCELLED,\n // FAILURE_CLIENT_TIMEOUT;\n\n // private final NfStatus nfStatus;\n // private final int responseStatus;\n //\n // CompleteReason(NfStatus nfStatus, int responseStatus) {\n // this.nfStatus = nfStatus;\n // this.responseStatus = responseStatus;\n // }\n //\n // CompleteReason() {\n // //For status that never gets returned back to client, like channel inactive\n // nfStatus = null;\n // responseStatus = 501;\n // }\n //\n // public NfStatus getNfStatus() {\n // return nfStatus;\n // }\n //\n // public int getResponseStatus() {\n // return responseStatus;\n // }\n }\n\n public static class StartEvent {\n private final HttpRequest request;\n\n public StartEvent(HttpRequest request) {\n this.request = request;\n }\n\n public HttpRequest getRequest() {\n return request;\n }\n }\n\n public static class CompleteEvent {\n private final CompleteReason reason;\n private final HttpRequest request;\n private final HttpResponse response;\n\n public CompleteEvent(CompleteReason reason, HttpRequest request, HttpResponse response) {\n this.reason = reason;\n this.request = request;\n this.response = response;\n }\n\n public CompleteReason getReason() {\n return reason;\n }\n\n public HttpRequest getRequest() {\n return request;\n }\n\n public HttpResponse getResponse() {\n return response;\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpRequestReadTimeoutEvent.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\n/**\n * Indicates a timeout in reading the full http request.\n *\n * ie. time between receiving request headers and LastHttpContent of request body.\n */\npublic class HttpRequestReadTimeoutEvent {\n public static final HttpRequestReadTimeoutEvent INSTANCE = new HttpRequestReadTimeoutEvent();\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpRequestReadTimeoutHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.spectator.api.Counter;\nimport com.netflix.zuul.passport.CurrentPassport;\nimport com.netflix.zuul.passport.PassportState;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.channel.ChannelPipeline;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.LastHttpContent;\nimport io.netty.handler.timeout.ReadTimeoutHandler;\nimport java.util.concurrent.TimeUnit;\n\n/**\n * This handler times from the point a HttpRequest is read until the LastHttpContent is read,\n * and fires a HttpRequestTimeoutEvent if that time has exceed the configured timeout.\n *\n * Unlike ReadTimeoutHandler, this impl does NOT close the channel on a timeout. Only fires the\n * event.\n *\n * @author michaels\n */\npublic class HttpRequestReadTimeoutHandler extends ChannelInboundHandlerAdapter {\n private static final String HANDLER_NAME = \"http_request_read_timeout_handler\";\n private static final String INTERNAL_HANDLER_NAME = \"http_request_read_timeout_internal\";\n\n private final long timeout;\n private final TimeUnit unit;\n private final Counter httpRequestReadTimeoutCounter;\n\n protected HttpRequestReadTimeoutHandler(long timeout, TimeUnit unit, Counter httpRequestReadTimeoutCounter) {\n this.timeout = timeout;\n this.unit = unit;\n this.httpRequestReadTimeoutCounter = httpRequestReadTimeoutCounter;\n }\n\n /**\n * Factory which ensures that this handler is added to the pipeline using the\n * correct name.\n */\n public static void addLast(\n ChannelPipeline pipeline, long timeout, TimeUnit unit, Counter httpRequestReadTimeoutCounter) {\n HttpRequestReadTimeoutHandler handler =\n new HttpRequestReadTimeoutHandler(timeout, unit, httpRequestReadTimeoutCounter);\n pipeline.addLast(HANDLER_NAME, handler);\n }\n\n @Override\n public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\n if (msg instanceof LastHttpContent) {\n removeInternalHandler(ctx);\n } else if (msg instanceof HttpRequest) {\n // Start timeout handler.\n InternalReadTimeoutHandler handler = new InternalReadTimeoutHandler(timeout, unit);\n ctx.pipeline().addBefore(HANDLER_NAME, INTERNAL_HANDLER_NAME, handler);\n }\n\n super.channelRead(ctx, msg);\n }\n\n @Override\n public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {\n if (evt instanceof HttpRequestReadTimeoutEvent) {\n CurrentPassport.fromChannel(ctx.channel()).add(PassportState.IN_REQ_READ_TIMEOUT);\n removeInternalHandler(ctx);\n httpRequestReadTimeoutCounter.increment();\n }\n\n super.userEventTriggered(ctx, evt);\n }\n\n @Override\n public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {\n removeInternalHandler(ctx);\n super.handlerRemoved(ctx);\n }\n\n @Override\n public void channelInactive(ChannelHandlerContext ctx) throws Exception {\n removeInternalHandler(ctx);\n super.channelInactive(ctx);\n }\n\n protected void removeInternalHandler(ChannelHandlerContext ctx) {\n // Remove timeout handler if not already removed.\n ChannelHandlerContext handlerContext = ctx.pipeline().context(INTERNAL_HANDLER_NAME);\n if (handlerContext != null && !handlerContext.isRemoved()) {\n ctx.pipeline().remove(INTERNAL_HANDLER_NAME);\n }\n }\n\n static class InternalReadTimeoutHandler extends ReadTimeoutHandler {\n public InternalReadTimeoutHandler(long timeout, TimeUnit unit) {\n super(timeout, unit);\n }\n\n @Override\n protected void readTimedOut(ChannelHandlerContext ctx) throws Exception {\n ctx.fireUserEventTriggered(HttpRequestReadTimeoutEvent.INSTANCE);\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/HttpServerLifecycleChannelHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.zuul.passport.PassportState;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.channel.ChannelOutboundHandlerAdapter;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.HttpResponse;\nimport io.netty.handler.codec.http.HttpResponseStatus;\nimport io.netty.handler.codec.http.LastHttpContent;\nimport io.netty.util.ReferenceCountUtil;\nimport java.util.Objects;\n\n/**\n * @author michaels\n */\npublic final class HttpServerLifecycleChannelHandler extends HttpLifecycleChannelHandler {\n public static final class HttpServerLifecycleInboundChannelHandler extends ChannelInboundHandlerAdapter {\n @Override\n public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\n if (msg instanceof HttpRequest) {\n // Fire start event, and if that succeeded, then allow processing to\n // continue to next handler in pipeline.\n if (fireStartEvent(ctx, (HttpRequest) msg)) {\n super.channelRead(ctx, msg);\n } else {\n ReferenceCountUtil.release(msg);\n }\n } else {\n super.channelRead(ctx, msg);\n }\n }\n\n @Override\n public void channelInactive(ChannelHandlerContext ctx) throws Exception {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.INACTIVE);\n\n super.channelInactive(ctx);\n }\n }\n\n public static final class HttpServerLifecycleOutboundChannelHandler extends ChannelOutboundHandlerAdapter {\n @Override\n public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {\n if (msg instanceof HttpResponse) {\n ctx.channel().attr(ATTR_HTTP_RESP).set((HttpResponse) msg);\n }\n\n try {\n super.write(ctx, msg, promise);\n } finally {\n if (msg instanceof LastHttpContent) {\n\n boolean dontFireCompleteYet = false;\n if (msg instanceof HttpResponse) {\n // Handle case of 100 CONTINUE, where server sends an initial 100 status response to indicate to\n // client\n // that it can continue sending the initial request body.\n // ie. in this case we don't want to consider the state to be COMPLETE until after the 2nd\n // response.\n if (Objects.equals(((HttpResponse) msg).status(), HttpResponseStatus.CONTINUE)) {\n dontFireCompleteYet = true;\n }\n }\n\n if (!dontFireCompleteYet) {\n if (promise.isDone()) {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.SESSION_COMPLETE);\n } else {\n promise.addListener(future -> {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.SESSION_COMPLETE);\n });\n }\n }\n }\n }\n }\n\n @Override\n public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.DISCONNECT);\n\n super.disconnect(ctx, promise);\n }\n\n @Override\n public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {\n addPassportState(ctx, PassportState.SERVER_CH_CLOSE);\n // This will likely expand based on more specific reasons for completion\n if (ctx.channel()\n .attr(HttpLifecycleChannelHandler.ATTR_HTTP_PIPELINE_REJECT)\n .get()\n == null) {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.CLOSE);\n } else {\n fireCompleteEventIfNotAlready(ctx, CompleteReason.PIPELINE_REJECT);\n }\n super.close(ctx, promise);\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/RequestResponseCompleteEvent.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\n/**\n * User: michaels@netflix.com\n * Date: 5/24/16\n * Time: 1:04 PM\n */\npublic class RequestResponseCompleteEvent {}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/SourceAddressChannelHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.google.common.annotations.VisibleForTesting;\nimport io.netty.channel.Channel;\nimport io.netty.channel.ChannelHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.util.AttributeKey;\nimport java.net.Inet4Address;\nimport java.net.Inet6Address;\nimport java.net.InetAddress;\nimport java.net.InetSocketAddress;\nimport java.net.SocketAddress;\nimport java.net.UnknownHostException;\nimport javax.annotation.Nullable;\n\n/**\n * Stores the source IP address as an attribute of the channel. This has the advantage of allowing us to overwrite it if\n * we have more info (eg. ELB sends a HAProxyMessage with info of REAL source host + port).\n *
\n * User: michaels@netflix.com Date: 4/14/16 Time: 4:29 PM\n */\n@ChannelHandler.Sharable\npublic final class SourceAddressChannelHandler extends ChannelInboundHandlerAdapter {\n\n /**\n * Indicates the actual source (remote) address of the channel. This can be different than the one {@link Channel}\n * returns if the connection is being proxied. (e.g. over HAProxy)\n */\n public static final AttributeKey ATTR_REMOTE_ADDR = AttributeKey.newInstance(\"_remote_addr\");\n\n /**\n * Indicates the destination address received from Proxy Protocol. Not set otherwise\n */\n public static final AttributeKey ATTR_PROXY_PROTOCOL_DESTINATION_ADDRESS =\n AttributeKey.newInstance(\"_proxy_protocol_destination_address\");\n\n /**\n * Use {@link #ATTR_REMOTE_ADDR} instead.\n */\n @Deprecated\n public static final AttributeKey ATTR_SOURCE_INET_ADDR =\n AttributeKey.newInstance(\"_source_inet_addr\");\n\n /**\n * The host address of the source. This is derived from {@link #ATTR_REMOTE_ADDR}. If the address is an IPv6\n * address, the scope identifier is absent.\n */\n public static final AttributeKey ATTR_SOURCE_ADDRESS = AttributeKey.newInstance(\"_source_address\");\n\n /**\n * Indicates the local address of the channel. This can be different than the one {@link Channel} returns if the\n * connection is being proxied. (e.g. over HAProxy)\n */\n public static final AttributeKey ATTR_LOCAL_ADDR = AttributeKey.newInstance(\"_local_addr\");\n\n /**\n * Use {@link #ATTR_LOCAL_ADDR} instead.\n */\n @Deprecated\n public static final AttributeKey ATTR_LOCAL_INET_ADDR =\n AttributeKey.newInstance(\"_local_inet_addr\");\n\n /**\n * The local address of this channel. This is derived from {@code channel.localAddress()}, or from the Proxy\n * Protocol preface if provided. If the address is an IPv6 address, the scope identifier is absent. Unlike {@link\n * #ATTR_SERVER_LOCAL_ADDRESS}, this value is overwritten with the Proxy Protocol local address (e.g. the LB's local\n * address), if enabled.\n */\n public static final AttributeKey ATTR_LOCAL_ADDRESS = AttributeKey.newInstance(\"_local_address\");\n\n /**\n * The actual local address of the channel, in string form. If the address is an IPv6 address, the scope identifier\n * is absent. Unlike {@link #ATTR_LOCAL_ADDRESS}, this is not overwritten by the Proxy Protocol message if\n * present.\n *\n * @deprecated Use {@code channel.localAddress()} instead.\n */\n @Deprecated\n public static final AttributeKey ATTR_SERVER_LOCAL_ADDRESS =\n AttributeKey.newInstance(\"_server_local_address\");\n\n /**\n * The port number of the local socket, or {@code -1} if not appropriate. This is not overwritten by the Proxy\n * Protocol message if present.\n */\n public static final AttributeKey ATTR_SERVER_LOCAL_PORT = AttributeKey.newInstance(\"_server_local_port\");\n\n @Override\n public void channelActive(ChannelHandlerContext ctx) throws Exception {\n ctx.channel().attr(ATTR_REMOTE_ADDR).set(ctx.channel().remoteAddress());\n InetSocketAddress sourceAddress = sourceAddress(ctx.channel());\n ctx.channel().attr(ATTR_SOURCE_INET_ADDR).setIfAbsent(sourceAddress);\n ctx.channel().attr(ATTR_SOURCE_ADDRESS).setIfAbsent(getHostAddress(sourceAddress));\n ctx.channel().attr(ATTR_LOCAL_ADDR).set(ctx.channel().localAddress());\n InetSocketAddress localAddress = localAddress(ctx.channel());\n ctx.channel().attr(ATTR_LOCAL_INET_ADDR).setIfAbsent(localAddress);\n ctx.channel().attr(ATTR_LOCAL_ADDRESS).setIfAbsent(getHostAddress(localAddress));\n // ATTR_LOCAL_ADDRESS and ATTR_LOCAL_PORT get overwritten with what is received in\n // Proxy Protocol (via the LB), so set local server's address, port explicitly\n ctx.channel()\n .attr(ATTR_SERVER_LOCAL_ADDRESS)\n .setIfAbsent(localAddress.getAddress().getHostAddress());\n ctx.channel().attr(ATTR_SERVER_LOCAL_PORT).setIfAbsent(localAddress.getPort());\n\n super.channelActive(ctx);\n }\n\n /**\n * Returns the String form of a socket address, or {@code null} if there isn't one.\n */\n @VisibleForTesting\n @Nullable\n static String getHostAddress(InetSocketAddress socketAddress) {\n InetAddress address = socketAddress.getAddress();\n if (address instanceof Inet6Address) {\n // Strip the scope from the address since some other classes choke on it.\n // TODO(carl-mastrangelo): Consider adding this back in once issues like\n // https://github.com/google/guava/issues/2587 are fixed.\n try {\n return InetAddress.getByAddress(address.getAddress()).getHostAddress();\n } catch (UnknownHostException e) {\n throw new RuntimeException(e);\n }\n } else if (address instanceof Inet4Address) {\n return address.getHostAddress();\n } else {\n assert address == null;\n return null;\n }\n }\n\n private InetSocketAddress sourceAddress(Channel channel) {\n SocketAddress remoteSocketAddr = channel.remoteAddress();\n if (remoteSocketAddr != null && InetSocketAddress.class.isAssignableFrom(remoteSocketAddr.getClass())) {\n InetSocketAddress inetSocketAddress = (InetSocketAddress) remoteSocketAddr;\n if (inetSocketAddress.getAddress() != null) {\n return inetSocketAddress;\n }\n }\n return null;\n }\n\n private InetSocketAddress localAddress(Channel channel) {\n SocketAddress localSocketAddress = channel.localAddress();\n if (localSocketAddress != null && InetSocketAddress.class.isAssignableFrom(localSocketAddress.getClass())) {\n InetSocketAddress inetSocketAddress = (InetSocketAddress) localSocketAddress;\n if (inetSocketAddress.getAddress() != null) {\n return inetSocketAddress;\n }\n }\n return null;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/SslExceptionsHandler.java",
"content": "/*\n * Copyright 2023 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.spectator.api.Registry;\nimport io.netty.channel.ChannelHandler.Sharable;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport javax.net.ssl.SSLHandshakeException;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * Swallow specific SSL related exceptions to avoid propagating deep stack traces up the pipeline.\n *\n * @author Argha C\n * @since 4/17/23\n */\n@Sharable\npublic class SslExceptionsHandler extends ChannelInboundHandlerAdapter {\n\n private static final Logger logger = LoggerFactory.getLogger(SslExceptionsHandler.class);\n private final Registry registry;\n\n public SslExceptionsHandler(Registry registry) {\n this.registry = registry;\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {\n // In certain cases, depending on the client, these stack traces can get very deep.\n // We intentionally avoid propagating this up the pipeline, to avoid verbose disk logging.\n if (cause.getCause() instanceof SSLHandshakeException) {\n logger.debug(\"SSL handshake failed on channel {}\", ctx.channel(), cause);\n registry.counter(\"server.ssl.exception.swallowed\", \"cause\", \"SSLHandshakeException\")\n .increment();\n } else {\n super.exceptionCaught(ctx, cause);\n }\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/SwallowSomeHttp2ExceptionsHandler.java",
"content": "/*\n * Copyright 2019 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common;\n\nimport com.netflix.spectator.api.Registry;\nimport io.netty.channel.ChannelHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelOutboundHandlerAdapter;\nimport io.netty.channel.unix.Errors;\nimport io.netty.handler.codec.http2.Http2Error;\nimport io.netty.handler.codec.http2.Http2Exception;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n@ChannelHandler.Sharable\npublic class SwallowSomeHttp2ExceptionsHandler extends ChannelOutboundHandlerAdapter {\n private static final Logger LOG = LoggerFactory.getLogger(SwallowSomeHttp2ExceptionsHandler.class);\n\n private final Registry registry;\n\n public SwallowSomeHttp2ExceptionsHandler(Registry registry) {\n this.registry = registry;\n }\n\n @Override\n public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {\n incrementExceptionCounter(cause);\n\n if (cause instanceof Http2Exception h2e) {\n if (h2e.error() == Http2Error.NO_ERROR\n && h2e.shutdownHint().equals(Http2Exception.ShutdownHint.GRACEFUL_SHUTDOWN)) {\n // This is the exception we threw ourselves to make the http2 codec gracefully close the connection. So\n // just\n // swallow it so that it doesn't propagate and get logged.\n LOG.debug(\"Swallowed Http2Exception.ShutdownHint.GRACEFUL_SHUTDOWN \", cause);\n } else {\n super.exceptionCaught(ctx, cause);\n }\n } else if (cause instanceof Errors.NativeIoException) {\n LOG.debug(\"Swallowed NativeIoException\", cause);\n } else {\n super.exceptionCaught(ctx, cause);\n }\n }\n\n private void incrementExceptionCounter(Throwable throwable) {\n registry.counter(\n \"server.connection.pipeline.exception\",\n \"id\",\n throwable.getClass().getSimpleName())\n .increment();\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/accesslog/AccessLogChannelHandler.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.accesslog;\n\nimport com.netflix.netty.common.HttpLifecycleChannelHandler;\nimport com.netflix.netty.common.SourceAddressChannelHandler;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.channel.ChannelInboundHandlerAdapter;\nimport io.netty.channel.ChannelOutboundHandlerAdapter;\nimport io.netty.channel.ChannelPromise;\nimport io.netty.handler.codec.http.HttpContent;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.HttpResponse;\nimport io.netty.util.AttributeKey;\nimport java.time.LocalDateTime;\nimport java.time.ZoneId;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\n/**\n * User: michaels@netflix.com\n * Date: 4/14/16\n * Time: 3:51 PM\n */\npublic final class AccessLogChannelHandler {\n private static final AttributeKey ATTR_REQ_STATE =\n AttributeKey.newInstance(\"_accesslog_requeststate\");\n\n private static final Logger LOG = LoggerFactory.getLogger(AccessLogChannelHandler.class);\n\n public static class AccessLogInboundChannelHandler extends ChannelInboundHandlerAdapter {\n private final AccessLogPublisher publisher;\n\n public AccessLogInboundChannelHandler(AccessLogPublisher publisher) {\n this.publisher = publisher;\n }\n\n protected Integer getLocalPort(ChannelHandlerContext ctx) {\n return ctx.channel()\n .attr(SourceAddressChannelHandler.ATTR_SERVER_LOCAL_PORT)\n .get();\n }\n\n protected String getRemoteIp(ChannelHandlerContext ctx) {\n return ctx.channel()\n .attr(SourceAddressChannelHandler.ATTR_SOURCE_ADDRESS)\n .get();\n }\n\n @Override\n public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {\n if (msg instanceof HttpRequest) {\n RequestState state = new RequestState();\n state.request = (HttpRequest) msg;\n state.startTimeNs = System.nanoTime();\n state.requestBodySize = 0;\n ctx.channel().attr(ATTR_REQ_STATE).set(state);\n }\n\n if (msg instanceof HttpContent) {\n RequestState state = ctx.channel().attr(ATTR_REQ_STATE).get();\n if (state != null) {\n state.requestBodySize += ((HttpContent) msg).content().readableBytes();\n }\n }\n\n super.channelRead(ctx, msg);\n }\n\n @Override\n public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {\n if (evt instanceof HttpLifecycleChannelHandler.CompleteEvent) {\n // Get the stored request, and remove the attr from channel to cleanup.\n RequestState state = ctx.channel().attr(ATTR_REQ_STATE).get();\n ctx.channel().attr(ATTR_REQ_STATE).set(null);\n\n // Response complete, so now write to access log.\n long durationNs = System.nanoTime() - state.startTimeNs;\n\n Integer localPort = getLocalPort(ctx);\n String remoteIp = getRemoteIp(ctx);\n\n if (state.response == null) {\n LOG.debug(\n \"Response null in AccessLog, Complete reason={}, duration={}, url={}, method={}\",\n ((HttpLifecycleChannelHandler.CompleteEvent) evt).getReason(),\n durationNs / (1000 * 1000),\n state.request != null ? state.request.uri() : \"-\",\n state.request != null ? state.request.method() : \"-\");\n }\n\n publisher.log(\n ctx.channel(),\n state.request,\n state.response,\n state.dateTime,\n localPort,\n remoteIp,\n durationNs,\n state.requestBodySize,\n state.responseBodySize);\n }\n\n super.userEventTriggered(ctx, evt);\n }\n }\n\n public static final class AccessLogOutboundChannelHandler extends ChannelOutboundHandlerAdapter {\n @Override\n public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {\n RequestState state = ctx.channel().attr(ATTR_REQ_STATE).get();\n\n if (msg instanceof HttpResponse) {\n state.response = (HttpResponse) msg;\n state.responseBodySize = 0;\n }\n\n if (msg instanceof HttpContent) {\n state.responseBodySize += ((HttpContent) msg).content().readableBytes();\n }\n\n super.write(ctx, msg, promise);\n }\n }\n\n private static class RequestState {\n final LocalDateTime dateTime = LocalDateTime.now(ZoneId.systemDefault());\n HttpRequest request;\n HttpResponse response;\n long startTimeNs;\n long requestBodySize = 0;\n long responseBodySize = 0;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/accesslog/AccessLogPublisher.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.accesslog;\n\nimport com.netflix.config.DynamicIntProperty;\nimport com.netflix.config.DynamicStringListProperty;\nimport io.netty.channel.Channel;\nimport io.netty.handler.codec.http.HttpHeaders;\nimport io.netty.handler.codec.http.HttpRequest;\nimport io.netty.handler.codec.http.HttpResponse;\nimport java.time.LocalDateTime;\nimport java.time.format.DateTimeFormatter;\nimport java.util.List;\nimport java.util.Locale;\nimport java.util.function.BiFunction;\nimport org.slf4j.Logger;\nimport org.slf4j.LoggerFactory;\n\npublic class AccessLogPublisher {\n private static final char DELIM = '\\t';\n private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;\n\n private static final List LOG_REQ_HEADERS = new DynamicStringListProperty(\n \"zuul.access.log.requestheaders\",\n \"host,x-forwarded-for,x-forwarded-proto,x-forwarded-host,x-forwarded-port,user-agent\")\n .get();\n private static final List LOG_RESP_HEADERS =\n new DynamicStringListProperty(\"zuul.access.log.responseheaders\", \"server,via,content-type\").get();\n private static final DynamicIntProperty URI_LENGTH_LIMIT =\n new DynamicIntProperty(\"zuul.access.log.uri.length.limit\", Integer.MAX_VALUE);\n\n private final Logger logger;\n private final BiFunction requestIdProvider;\n\n private static final Logger LOG = LoggerFactory.getLogger(AccessLogPublisher.class);\n\n public AccessLogPublisher(String loggerName, BiFunction requestIdProvider) {\n this.logger = LoggerFactory.getLogger(loggerName);\n this.requestIdProvider = requestIdProvider;\n }\n\n public void log(\n Channel channel,\n HttpRequest request,\n HttpResponse response,\n LocalDateTime dateTime,\n Integer localPort,\n String remoteIp,\n Long durationNs,\n Long requestBodySize,\n Long responseBodySize) {\n StringBuilder sb = new StringBuilder(512);\n\n String dateTimeStr = dateTime != null ? dateTime.format(DATE_TIME_FORMATTER) : \"-----T-:-:-\";\n String remoteIpStr = (remoteIp != null && !remoteIp.isEmpty()) ? remoteIp : \"-\";\n String port = localPort != null ? localPort.toString() : \"-\";\n String method = request != null ? request.method().toString().toUpperCase(Locale.ROOT) : \"-\";\n String uri = request != null ? request.uri() : \"-\";\n if (uri.length() > URI_LENGTH_LIMIT.get()) {\n uri = uri.substring(0, URI_LENGTH_LIMIT.get());\n }\n String status = response != null ? String.valueOf(response.status().code()) : \"-\";\n\n String requestId = null;\n try {\n requestId = requestIdProvider.apply(channel, request);\n } catch (Exception ex) {\n LOG.error(\n \"requestIdProvider failed in AccessLogPublisher method={}, uri={}, status={}\", method, uri, status);\n }\n requestId = requestId != null ? requestId : \"-\";\n\n // Convert duration to microseconds.\n String durationStr = (durationNs != null && durationNs > 0) ? String.valueOf(durationNs / 1000) : \"-\";\n\n String requestBodySizeStr = (requestBodySize != null && requestBodySize > 0) ? requestBodySize.toString() : \"-\";\n String responseBodySizeStr =\n (responseBodySize != null && responseBodySize > 0) ? responseBodySize.toString() : \"-\";\n\n // Build the line.\n sb.append(dateTimeStr)\n .append(DELIM)\n .append(remoteIpStr)\n .append(DELIM)\n .append(port)\n .append(DELIM)\n .append(method)\n .append(DELIM)\n .append(uri)\n .append(DELIM)\n .append(status)\n .append(DELIM)\n .append(durationStr)\n .append(DELIM)\n .append(responseBodySizeStr)\n .append(DELIM)\n .append(requestId)\n .append(DELIM)\n .append(requestBodySizeStr);\n\n if (request != null && request.headers() != null) {\n includeMatchingHeaders(sb, LOG_REQ_HEADERS, request.headers());\n }\n\n if (response != null && response.headers() != null) {\n includeMatchingHeaders(sb, LOG_RESP_HEADERS, response.headers());\n }\n\n // Write to logger.\n String access = sb.toString();\n logger.info(access);\n LOG.debug(access);\n }\n\n void includeMatchingHeaders(StringBuilder builder, List requiredHeaders, HttpHeaders headers) {\n for (String headerName : requiredHeaders) {\n String value = headerAsString(headers, headerName);\n builder.append(DELIM).append('\\\"').append(value).append('\\\"');\n }\n }\n\n String headerAsString(HttpHeaders headers, String headerName) {\n List values = headers.getAll(headerName);\n return values.isEmpty() ? \"-\" : String.join(\",\", values);\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/channel/config/ChannelConfig.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.channel.config;\n\nimport java.util.HashMap;\nimport java.util.Map;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 6:43 PM\n */\npublic class ChannelConfig implements Cloneable {\n private final HashMap parameters;\n\n public ChannelConfig() {\n parameters = new HashMap<>();\n }\n\n public ChannelConfig(Map parameters) {\n this.parameters = new HashMap(parameters);\n }\n\n public void add(ChannelConfigValue param) {\n this.parameters.put(param.key(), param);\n }\n\n public void set(ChannelConfigKey key, T value) {\n this.parameters.put(key, new ChannelConfigValue<>(key, value));\n }\n\n public T get(ChannelConfigKey key) {\n ChannelConfigValue ccv = parameters.get(key);\n T value = ccv == null ? null : (T) ccv.value();\n\n if (value == null) {\n value = key.defaultValue();\n }\n\n return value;\n }\n\n public ChannelConfigValue getConfig(ChannelConfigKey key) {\n return (ChannelConfigValue) parameters.get(key);\n }\n\n public boolean contains(ChannelConfigKey key) {\n return parameters.containsKey(key);\n }\n\n @Override\n public ChannelConfig clone() {\n return new ChannelConfig(parameters);\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/channel/config/ChannelConfigKey.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.channel.config;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 6:17 PM\n */\npublic class ChannelConfigKey {\n private final String key;\n private final T defaultValue;\n\n public ChannelConfigKey(String key, T defaultValue) {\n this.key = key;\n this.defaultValue = defaultValue;\n }\n\n public ChannelConfigKey(String key) {\n this.key = key;\n this.defaultValue = null;\n }\n\n public String key() {\n return key;\n }\n\n public T defaultValue() {\n return defaultValue;\n }\n\n public boolean hasDefaultValue() {\n return defaultValue != null;\n }\n\n @Override\n public String toString() {\n return \"ChannelConfigKey{\" + \"key='\" + key + '\\'' + \", defaultValue=\" + defaultValue + '}';\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/channel/config/ChannelConfigValue.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.channel.config;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 6:41 PM\n */\npublic class ChannelConfigValue {\n private final ChannelConfigKey key;\n private final T value;\n\n public ChannelConfigValue(ChannelConfigKey key, T value) {\n this.key = key;\n this.value = value;\n }\n\n public ChannelConfigKey key() {\n return key;\n }\n\n public T value() {\n return value;\n }\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/channel/config/CommonChannelConfigKeys.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.channel.config;\n\nimport com.netflix.netty.common.proxyprotocol.StripUntrustedProxyHeadersHandler;\nimport com.netflix.netty.common.ssl.ServerSslConfig;\nimport com.netflix.zuul.netty.server.ServerTimeout;\nimport com.netflix.zuul.netty.ssl.SslContextFactory;\nimport io.netty.handler.ssl.SslContext;\nimport io.netty.util.AsyncMapping;\n\n/**\n * User: michaels@netflix.com\n * Date: 2/8/17\n * Time: 6:21 PM\n */\npublic class CommonChannelConfigKeys {\n public static final ChannelConfigKey withProxyProtocol =\n new ChannelConfigKey<>(\"withProxyProtocol\", false);\n public static final ChannelConfigKey allowProxyHeadersWhen =\n new ChannelConfigKey<>(\"allowProxyHeadersWhen\", StripUntrustedProxyHeadersHandler.AllowWhen.ALWAYS);\n public static final ChannelConfigKey preferProxyProtocolForClientIp =\n new ChannelConfigKey<>(\"preferProxyProtocolForClientIp\", true);\n\n /** The Idle timeout of a connection, in milliseconds */\n public static final ChannelConfigKey idleTimeout = new ChannelConfigKey<>(\"idleTimeout\", 65000);\n\n public static final ChannelConfigKey serverTimeout = new ChannelConfigKey<>(\"serverTimeout\");\n /** The HTTP request read timeout, in milliseconds */\n public static final ChannelConfigKey httpRequestReadTimeout =\n new ChannelConfigKey<>(\"httpRequestReadTimeout\", 5000);\n /** The maximum number of inbound connections to proxy. */\n public static final ChannelConfigKey maxConnections = new ChannelConfigKey<>(\"maxConnections\", 20000);\n\n public static final ChannelConfigKey maxRequestsPerConnection =\n new ChannelConfigKey<>(\"maxRequestsPerConnection\", 4000);\n public static final ChannelConfigKey maxRequestsPerConnectionInBrownout =\n new ChannelConfigKey<>(\"maxRequestsPerConnectionInBrownout\", 100);\n public static final ChannelConfigKey connectionExpiry =\n new ChannelConfigKey<>(\"connectionExpiry\", 20 * 60 * 1000);\n\n // SSL:\n public static final ChannelConfigKey isSSlFromIntermediary =\n new ChannelConfigKey<>(\"isSSlFromIntermediary\", false);\n public static final ChannelConfigKey serverSslConfig = new ChannelConfigKey<>(\"serverSslConfig\");\n public static final ChannelConfigKey sslContextFactory =\n new ChannelConfigKey<>(\"sslContextFactory\");\n public static final ChannelConfigKey> sniMapping =\n new ChannelConfigKey<>(\"sniMapping\");\n\n // HTTP/2 specific:\n public static final ChannelConfigKey maxConcurrentStreams =\n new ChannelConfigKey<>(\"maxConcurrentStreams\", 100);\n public static final ChannelConfigKey initialWindowSize =\n new ChannelConfigKey<>(\"initialWindowSize\", 5242880); // 5MB\n /* The amount of time to wait before closing a connection that has the `Connection: Close` header, in seconds */\n public static final ChannelConfigKey connCloseDelay = new ChannelConfigKey<>(\"connCloseDelay\", 10);\n public static final ChannelConfigKey maxHttp2HeaderTableSize =\n new ChannelConfigKey<>(\"maxHttp2HeaderTableSize\", 4096);\n public static final ChannelConfigKey maxHttp2HeaderListSize =\n new ChannelConfigKey<>(\"maxHttp2HeaderListSize\");\n public static final ChannelConfigKey http2AllowGracefulDelayed =\n new ChannelConfigKey<>(\"http2AllowGracefulDelayed\", true);\n public static final ChannelConfigKey http2SwallowUnknownExceptionsOnConnClose =\n new ChannelConfigKey<>(\"http2SwallowUnknownExceptionsOnConnClose\", false);\n public static final ChannelConfigKey http2CatchConnectionErrors =\n new ChannelConfigKey<>(\"http2CatchConnectionErrors\", true);\n public static final ChannelConfigKey http2EncoderMaxResetFrames =\n new ChannelConfigKey<>(\"http2EncoderMaxResetFrames\", 200);\n public static final ChannelConfigKey http2EncoderMaxResetFramesWindow =\n new ChannelConfigKey<>(\"http2EncoderMaxResetFramesWindow\", 30);\n public static final ChannelConfigKey http2ConnectProtocolEnabled =\n new ChannelConfigKey<>(\"http2ConnectProtocolEnabled\", false);\n}\n"
},
{
"path": "zuul-core/src/main/java/com/netflix/netty/common/http2/DynamicHttp2FrameLogger.java",
"content": "/*\n * Copyright 2018 Netflix, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.netflix.netty.common.http2;\n\nimport com.google.errorprone.annotations.FormatMethod;\nimport com.google.errorprone.annotations.FormatString;\nimport com.netflix.config.DynamicStringSetProperty;\nimport io.netty.buffer.ByteBuf;\nimport io.netty.buffer.ByteBufUtil;\nimport io.netty.channel.ChannelHandlerContext;\nimport io.netty.handler.codec.http2.Http2Flags;\nimport io.netty.handler.codec.http2.Http2FrameLogger;\nimport io.netty.handler.codec.http2.Http2Headers;\nimport io.netty.handler.codec.http2.Http2Settings;\nimport io.netty.handler.logging.LogLevel;\nimport io.netty.util.AttributeKey;\nimport io.netty.util.internal.ObjectUtil;\nimport io.netty.util.internal.logging.InternalLogLevel;\nimport io.netty.util.internal.logging.InternalLogger;\nimport io.netty.util.internal.logging.InternalLoggerFactory;\n\npublic class DynamicHttp2FrameLogger extends Http2FrameLogger {\n public static final AttributeKey
![](\"https://i.imgur.com/mRSosEp.png\")
\n\n\nZuul is an L7 application gateway that provides capabilities for dynamic routing, monitoring, resiliency, security, and more.\nPlease view the wiki for usage, information, HOWTO, etc https://github.com/Netflix/zuul/wiki\n\nHere are some links to help you learn more about the Zuul Project. Feel free to PR to add any other info, presentations, etc.\n\n---\n\nArticles from Netflix:\n\nZuul 1: http://techblog.netflix.com/2013/06/announcing-zuul-edge-service-in-cloud.html\n\nZuul 2:\n\nhttps://netflixtechblog.com/open-sourcing-zuul-2-82ea476cb2b3\n\nhttps://netflixtechblog.com/zuul-2-the-netflix-journey-to-asynchronous-non-blocking-systems-45947377fb5c\n\nhttps://netflixtechblog.com/the-show-must-go-on-securing-netflix-studios-at-scale-19b801c86479\n\n---\n\nNetflix presentations about Zuul:\n\nStrange Loop 2017 - Zuul 2: https://youtu.be/2oXqbLhMS_A\n\nAWS re:Invent 2018 - Scaling push messaging for millions of Netflix devices: https://youtu.be/IdR6N9B-S1E\n \n---\n\nSlides from Netflix presentations about Zuul:\n\nhttp://www.slideshare.net/MikeyCohen1/zuul-netflix-springone-platform\n\nhttp://www.slideshare.net/MikeyCohen1/rethinking-cloud-proxies-54923218\n\nhttps://github.com/strangeloop/StrangeLoop2017/blob/master/slides/ArthurGonigberg-ZuulsJourneyToNonBlocking.pdf\n\nhttps://www.slideshare.net/SusheelAroskar/scaling-push-messaging-for-millions-of-netflix-devices\n\n---\n\nProjects Using Zuul:\n\nhttps://cloud.spring.io/\n\nhttps://jhipster.github.io/\n\n---\n\nInfo and examples from various projects:\n\nhttps://cloud.spring.io/spring-cloud-netflix/multi/multi__router_and_filter_zuul\n\nhttp://www.baeldung.com/spring-rest-with-zuul-proxy\n\nhttps://blog.heroku.com/using_netflix_zuul_to_proxy_your_microservices\n\nhttp://blog.ippon.tech/jhipster-3-0-introducing-microservices/\n\n---\n\nOther blog posts about Zuul:\n\nhttps://engineering.riotgames.com/news/riot-games-api-fulfilling-zuuls-destiny\n\nhttps://engineering.riotgames.com/news/riot-games-api-deep-dive\n\nhttp://instea.sk/2015/04/netflix-zuul-vs-nginx-performance/\n\n---\n\n\n# How to release Zuul\n\nThis project uses a GitHub Action workflow for publishing a new release.\nThe workflow is triggered by a Git tag.\n\n```\ngit checkout master\ngit tag vX.Y.Z\ngit push --tags\n```\n\n"
},
{
"path": "build.gradle",
"content": "buildscript {\n dependencies {\n classpath 'com.palantir.javaformat:gradle-palantir-java-format:2.83.0'\n }\n}\n\nplugins {\n id 'com.netflix.nebula.netflixoss' version '13.0.0'\n id \"com.google.osdetector\" version '1.7.3'\n id 'me.champeau.jmh' version '0.7.2'\n id 'org.openrewrite.rewrite' version '7.12.1'\n id 'net.ltgt.errorprone' version '4.1.0'\n id 'com.diffplug.spotless' version \"8.1.0\"\n id 'idea'\n}\n\next.githubProjectName = rootProject.name\n\n\nidea {\n project {\n languageLevel = '21'\n }\n}\n\nconfigurations.all {\n exclude group: 'asm', module: 'asm'\n exclude group: 'asm', module: 'asm-all'\n}\n\nallprojects {\n repositories {\n mavenCentral()\n }\n\n apply plugin: 'com.diffplug.spotless'\n\n spotless {\n enforceCheck false\n java {\n rootProject.hasProperty('spotlessJavaTarget') ? target(rootProject.getProperty('spotlessJavaTarget').split(\",\")) : target('src/*/java/**/*.java')\n removeUnusedImports('cleanthat-javaparser-unnecessaryimport')\n palantirJavaFormat()\n }\n }\n}\n\nsubprojects {\n apply plugin: 'com.netflix.nebula.netflixoss'\n apply plugin: 'java'\n apply plugin: 'com.netflix.nebula.javadoc-jar'\n apply plugin: 'com.netflix.nebula.dependency-lock'\n apply plugin: 'me.champeau.jmh'\n apply plugin: 'org.openrewrite.rewrite'\n apply plugin: 'net.ltgt.errorprone'\n\n license {\n ignoreFailures = false\n excludes([\n \"**/META-INF/services/javax.annotation.processing.Processor\",\n \"**/META-INF/gradle/incremental.annotation.processors\",\n \"**/*.cert\",\n \"**/*.jks\",\n \"**/*.key\",\n ])\n }\n\n group = \"com.netflix.${githubProjectName}\"\n\n java {\n toolchain {\n languageVersion = JavaLanguageVersion.of(21)\n }\n }\n\n tasks.withType(JavaCompile).configureEach {\n dependencies {\n errorprone \"com.uber.nullaway:nullaway:0.12.4\"\n errorprone \"com.google.errorprone:error_prone_core:2.45.0\"\n }\n\n options.compilerArgs << \"-Werror\"\n\n options.errorprone {\n check(\"NullAway\", net.ltgt.gradle.errorprone.CheckSeverity.OFF)\n option(\"NullAway:AnnotatedPackages\", \"com.netflix.zuul\")\n errorproneArgs.addAll(\n // Uncomment and remove -Werror javac flag to automatically apply fixes for a check.\n // N.B: disables all other checks while enabled.\n // \"-XepPatchChecks:UnnecessaryParentheses\",\n // \"-XepPatchLocation:IN_PLACE\",\n \"-Xep:ClassCanBeStatic:OFF\",\n \"-Xep:EmptyBlockTag:OFF\",\n \"-Xep:FutureReturnValueIgnored:OFF\",\n \"-Xep:InlineMeSuggester:OFF\",\n \"-Xep:MissingSummary:OFF\",\n )\n }\n }\n\n eclipse {\n classpath {\n downloadSources = true\n downloadJavadoc = true\n }\n }\n\n tasks.withType(Javadoc).each {\n it.classpath = sourceSets.main.compileClasspath\n // Ignore Javadoc warnings for now, re-enable after Zuul 3.\n it.options.addStringOption('Xdoclint:none', '-quiet')\n }\n\n ext {\n libraries = [\n guava: \"com.google.guava:guava:33.3.0-jre\",\n okhttp: 'com.squareup.okhttp3:okhttp:4.12.0',\n jupiterApi: 'org.junit.jupiter:junit-jupiter-api:5.13.+',\n jupiterParams: 'org.junit.jupiter:junit-jupiter-params:5.13.+',\n jupiterEngine: 'org.junit.jupiter:junit-jupiter-engine:5.13.+',\n junitPlatformLauncher: 'org.junit.platform:junit-platform-launcher:1.13.+',\n jupiterMockito: 'org.mockito:mockito-junit-jupiter:5.13.+',\n mockito: 'org.mockito:mockito-core:5.+',\n\n slf4j: \"org.slf4j:slf4j-api:2.0.16\",\n assertj: 'org.assertj:assertj-core:3.26.3',\n awaitility: 'org.awaitility:awaitility:4.2.2',\n lombok: 'org.projectlombok:lombok:1.18.42'\n ]\n }\n\n test {\n useJUnitPlatform()\n testLogging {\n showStandardStreams = true\n }\n maxParallelForks = Runtime.runtime.availableProcessors();\n }\n}\n\ndependencies {\n rewrite(platform(\"org.openrewrite.recipe:rewrite-recipe-bom:3.12.1\"))\n rewrite(\"org.openrewrite.recipe:rewrite-logging-frameworks\")\n rewrite(\"org.openrewrite.recipe:rewrite-testing-frameworks\")\n rewrite(\"org.openrewrite.recipe:rewrite-static-analysis\")\n}\n\nrewrite {\n failOnDryRunResults = true\n activeRecipe(\"org.openrewrite.java.testing.junit5.JUnit5BestPractices\")\n activeRecipe(\"org.openrewrite.java.logging.slf4j.Slf4jBestPractices\")\n}\n"
},
{
"path": "codequality/checkstyle.xml",
"content": "\n\n\n