#19348

Committed 10 Jul 2024 10:03PM CUT coverage: 88.448% (+0.02%) from 88.432%

Build # #19348

Build Type

push

github

Committed by

web-flow

Commit Message

Restore old behavior of NettyAdaptiveCumulator, but avoid using that class if Netty is on version 4.1.111 or later. (#11367) (#11373)

Run Details

32072 of 36261 relevant lines covered (88.45%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.0

/../netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java

/*
 * Copyright 2016 The gRPC Authors
 *
 * 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 io.grpc.netty;

import static com.google.common.base.Preconditions.checkState;

import com.google.common.annotations.VisibleForTesting;
import io.grpc.Attributes;
import io.grpc.ChannelLogger;
import io.grpc.Internal;
import io.grpc.InternalChannelz;
import io.netty.channel.ChannelPromise;
import io.netty.handler.codec.http2.Http2ConnectionDecoder;
import io.netty.handler.codec.http2.Http2ConnectionEncoder;
import io.netty.handler.codec.http2.Http2ConnectionHandler;
import io.netty.handler.codec.http2.Http2Settings;
import io.netty.util.Version;
import javax.annotation.Nullable;

/**
 * gRPC wrapper for {@link Http2ConnectionHandler}.
 */
@Internal
public abstract class GrpcHttp2ConnectionHandler extends Http2ConnectionHandler {
  static final int ADAPTIVE_CUMULATOR_COMPOSE_MIN_SIZE_DEFAULT = 1024;
  static final Cumulator ADAPTIVE_CUMULATOR =
      new NettyAdaptiveCumulator(ADAPTIVE_CUMULATOR_COMPOSE_MIN_SIZE_DEFAULT);

  @Nullable
  protected final ChannelPromise channelUnused;
  private final ChannelLogger negotiationLogger;
  private static final boolean usingPre4_1_111_Netty;

  static {
    // Netty 4.1.111 introduced a change in the behavior of duplicate() method
    // that breaks the assumption of the cumulator. We need to detect this version
    // and adjust the behavior accordingly.

    boolean identifiedOldVersion = false;
    try {
      Version version = Version.identify().get("netty-buffer");
      if (version != null) {
        String[] split = version.artifactVersion().split("\\.");
        if (split.length >= 3
            && Integer.parseInt(split[0]) == 4
            && Integer.parseInt(split[1]) <= 1
            && Integer.parseInt(split[2]) < 111) {
          identifiedOldVersion = true;
        }
      }
    } catch (Exception e) {
      // Ignore, we'll assume it's a new version.
    }
    usingPre4_1_111_Netty = identifiedOldVersion;
  }

  protected GrpcHttp2ConnectionHandler(
      ChannelPromise channelUnused,
      Http2ConnectionDecoder decoder,
      Http2ConnectionEncoder encoder,
      Http2Settings initialSettings,
      ChannelLogger negotiationLogger) {
    super(decoder, encoder, initialSettings);
    this.channelUnused = channelUnused;
    this.negotiationLogger = negotiationLogger;
    if (usingPre4_1_111_Netty()) {
      // We need to use the adaptive cumulator only if we're using a version of Netty that
      // doesn't have the behavior that breaks it.
      setCumulator(ADAPTIVE_CUMULATOR);
    }
  }

  @VisibleForTesting
  static boolean usingPre4_1_111_Netty() {
    return usingPre4_1_111_Netty;
  }

  /**
   * Same as {@link #handleProtocolNegotiationCompleted(
   *   Attributes, io.grpc.InternalChannelz.Security)}
   * but with no {@link io.grpc.InternalChannelz.Security}.
   *
   * @deprecated Use the two argument method instead.
   */
  @Deprecated
  @SuppressWarnings("InlineMeSuggester") // the caller should consider providing securityInfo
  public void handleProtocolNegotiationCompleted(Attributes attrs) {
    handleProtocolNegotiationCompleted(attrs, /*securityInfo=*/ null);
  }

  /**
   * Triggered on protocol negotiation completion.
   *
   * <p>It must me called after negotiation is completed but before given handler is added to the
   * channel.
   *
   * @param attrs arbitrary attributes passed after protocol negotiation (eg. SSLSession).
   * @param securityInfo informs channelz about the security protocol.
   */
  public void handleProtocolNegotiationCompleted(
      Attributes attrs, InternalChannelz.Security securityInfo) {
  }

  /**
   * Returns the channel logger for the given channel context.
   */
  public ChannelLogger getNegotiationLogger() {
    checkState(negotiationLogger != null, "NegotiationLogger must not be null");
    return negotiationLogger;
  }

  /**
   * Calling this method indicates that the channel will no longer be used.  This method is roughly
   * the same as calling {@link #close} on the channel, but leaving the channel alive.  This is
   * useful if the channel will soon be deregistered from the executor and used in a non-Netty
   * context.
   */
  @SuppressWarnings("FutureReturnValueIgnored")
  public void notifyUnused() {
    channelUnused.setSuccess(null);
  }

  /** Get the attributes of the EquivalentAddressGroup used to create this transport. */
  public Attributes getEagAttributes() {
    return Attributes.EMPTY;
  }

  /**
   * Returns the authority of the server. Only available on the client-side.
   *
   * @throws UnsupportedOperationException if on server-side
   */
  public String getAuthority() {
    throw new UnsupportedOperationException();
  }
}

1	/*
2	* Copyright 2016 The gRPC Authors
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package io.grpc.netty;
18
19	import static com.google.common.base.Preconditions.checkState;
20
21	import com.google.common.annotations.VisibleForTesting;
22	import io.grpc.Attributes;
23	import io.grpc.ChannelLogger;
24	import io.grpc.Internal;
25	import io.grpc.InternalChannelz;
26	import io.netty.channel.ChannelPromise;
27	import io.netty.handler.codec.http2.Http2ConnectionDecoder;
28	import io.netty.handler.codec.http2.Http2ConnectionEncoder;
29	import io.netty.handler.codec.http2.Http2ConnectionHandler;
30	import io.netty.handler.codec.http2.Http2Settings;
31	import io.netty.util.Version;
32	import javax.annotation.Nullable;
33
34	/**
35	* gRPC wrapper for {@link Http2ConnectionHandler}.
36	*/
37	@Internal
38	public abstract class GrpcHttp2ConnectionHandler extends Http2ConnectionHandler {
39	static final int ADAPTIVE_CUMULATOR_COMPOSE_MIN_SIZE_DEFAULT = 1024;
40	static final Cumulator ADAPTIVE_CUMULATOR =	1✔
41	new NettyAdaptiveCumulator(ADAPTIVE_CUMULATOR_COMPOSE_MIN_SIZE_DEFAULT);
42
43	@Nullable
44	protected final ChannelPromise channelUnused;
45	private final ChannelLogger negotiationLogger;
46	private static final boolean usingPre4_1_111_Netty;
47
48	static {
49	// Netty 4.1.111 introduced a change in the behavior of duplicate() method
50	// that breaks the assumption of the cumulator. We need to detect this version
51	// and adjust the behavior accordingly.
52
53	boolean identifiedOldVersion = false;	1✔
54	try {
55	Version version = Version.identify().get("netty-buffer");	1✔
56	if (version != null) {	1✔
57	String[] split = version.artifactVersion().split("\\.");	1✔
58	if (split.length >= 3	1✔
59	&& Integer.parseInt(split[0]) == 4	1✔
60	&& Integer.parseInt(split[1]) <= 1	1✔
61	&& Integer.parseInt(split[2]) < 111) {	1✔
62	identifiedOldVersion = true;	1✔
63	}
64	}
65	} catch (Exception e) {	×
66	// Ignore, we'll assume it's a new version.
67	}	1✔
68	usingPre4_1_111_Netty = identifiedOldVersion;	1✔
69	}	1✔
70
71	protected GrpcHttp2ConnectionHandler(
72	ChannelPromise channelUnused,
73	Http2ConnectionDecoder decoder,
74	Http2ConnectionEncoder encoder,
75	Http2Settings initialSettings,
76	ChannelLogger negotiationLogger) {
77	super(decoder, encoder, initialSettings);	1✔
78	this.channelUnused = channelUnused;	1✔
79	this.negotiationLogger = negotiationLogger;	1✔
80	if (usingPre4_1_111_Netty()) {	1✔
81	// We need to use the adaptive cumulator only if we're using a version of Netty that
82	// doesn't have the behavior that breaks it.
83	setCumulator(ADAPTIVE_CUMULATOR);	1✔
84	}
85	}	1✔
86
87	@VisibleForTesting
88	static boolean usingPre4_1_111_Netty() {
89	return usingPre4_1_111_Netty;	1✔
90	}
91
92	/**
93	* Same as {@link #handleProtocolNegotiationCompleted(
94	* Attributes, io.grpc.InternalChannelz.Security)}
95	* but with no {@link io.grpc.InternalChannelz.Security}.
96	*
97	* @deprecated Use the two argument method instead.
98	*/
99	@Deprecated
100	@SuppressWarnings("InlineMeSuggester") // the caller should consider providing securityInfo
101	public void handleProtocolNegotiationCompleted(Attributes attrs) {
102	handleProtocolNegotiationCompleted(attrs, /securityInfo=/ null);	×
103	}	×
104
105	/**
106	* Triggered on protocol negotiation completion.
107	*
108	* <p>It must me called after negotiation is completed but before given handler is added to the
109	* channel.
110	*
111	* @param attrs arbitrary attributes passed after protocol negotiation (eg. SSLSession).
112	* @param securityInfo informs channelz about the security protocol.
113	*/
114	public void handleProtocolNegotiationCompleted(
115	Attributes attrs, InternalChannelz.Security securityInfo) {
116	}	1✔
117
118	/**
119	* Returns the channel logger for the given channel context.
120	*/
121	public ChannelLogger getNegotiationLogger() {
122	checkState(negotiationLogger != null, "NegotiationLogger must not be null");	1✔
123	return negotiationLogger;	1✔
124	}
125
126	/**
127	* Calling this method indicates that the channel will no longer be used. This method is roughly
128	* the same as calling {@link #close} on the channel, but leaving the channel alive. This is
129	* useful if the channel will soon be deregistered from the executor and used in a non-Netty
130	* context.
131	*/
132	@SuppressWarnings("FutureReturnValueIgnored")
133	public void notifyUnused() {
134	channelUnused.setSuccess(null);	×
135	}	×
136
137	/** Get the attributes of the EquivalentAddressGroup used to create this transport. */
138	public Attributes getEagAttributes() {
139	return Attributes.EMPTY;	1✔
140	}
141
142	/**
143	* Returns the authority of the server. Only available on the client-side.
144	*
145	* @throws UnsupportedOperationException if on server-side
146	*/
147	public String getAuthority() {
148	throw new UnsupportedOperationException();	×
149	}
150	}

grpc / grpc-java / #19348

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous