private boolean autoFlowControl = DEFAULT_AUTO_FLOW_CONTROL;

private int flowControlWindow = DEFAULT_FLOW_CONTROL_WINDOW;

private int maxHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;

private int softLimitHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;

private int maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;

private long keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;

private long keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;

public NettyChannelBuilder maxInboundMetadataSize(int bytes) {

checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");

this.maxHeaderListSize = bytes;

// Clear the soft limit setting, by setting soft limit to maxInboundMetadataSize. The

// maxInboundMetadataSize will take precedence be applied before soft limit check.

this.softLimitHeaderListSize = bytes;

return this;

}

/**

* Sets the size of metadata that clients are advised to not exceed. When a metadata with size

* larger than the soft limit is encountered there will be a probability the RPC will fail. The

* chance of failing increases as the metadata size approaches the hard limit.

* {@code Integer.MAX_VALUE} disables the enforcement. The default is implementation-dependent,

* but is not generally less than 8 KiB and may be unlimited.

*

* <p>This is cumulative size of the metadata. The precise calculation is

* implementation-dependent, but implementations are encouraged to follow the calculation used

* for

* <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">HTTP/2's

* SETTINGS_MAX_HEADER_LIST_SIZE</a>. It sums the bytes from each entry's key and value, plus 32

* bytes of overhead per entry.

*

* @param soft the soft size limit of received metadata

* @param max the hard size limit of received metadata

* @return this

* @throws IllegalArgumentException if soft and/or max is non-positive, or max smaller than

* soft

* @since 1.68.0

*/

@CanIgnoreReturnValue

public NettyChannelBuilder maxInboundMetadataSize(int soft, int max) {

checkArgument(soft > 0, "softLimitHeaderListSize must be > 0");

checkArgument(max > soft,

"maxInboundMetadataSize must be greater than softLimitHeaderListSize");

this.softLimitHeaderListSize = soft;

this.maxHeaderListSize = max;

return this;

}

ProtocolNegotiator negotiator = protocolNegotiatorFactory.newNegotiator();

return new NettyTransportFactory(

negotiator, channelFactory, channelOptions,

eventLoopGroupPool, autoFlowControl, flowControlWindow, maxInboundMessageSize,

maxHeaderListSize, keepAliveTimeNanos, keepAliveTimeoutNanos, keepAliveWithoutCalls,

transportTracerFactory, localSocketPicker, useGetForSafeMethods, transportSocketType);

negotiator,

channelFactory,

channelOptions,

eventLoopGroupPool,

autoFlowControl,

flowControlWindow,

maxInboundMessageSize,

maxHeaderListSize,

softLimitHeaderListSize,

keepAliveTimeNanos,

keepAliveTimeoutNanos,

keepAliveWithoutCalls,

transportTracerFactory,

localSocketPicker,

useGetForSafeMethods,

transportSocketType);

}

@VisibleForTesting

private final int flowControlWindow;

private final int maxMessageSize;

private final int maxHeaderListSize;

private final int softLimitHeaderListSize;

private final long keepAliveTimeNanos;

private final AtomicBackoff keepAliveBackoff;

private final long keepAliveTimeoutNanos;

NettyTransportFactory(

ProtocolNegotiator protocolNegotiator,

ChannelFactory<? extends Channel> channelFactory,

Map<ChannelOption<?>, ?> channelOptions, ObjectPool<? extends EventLoopGroup> groupPool,

boolean autoFlowControl, int flowControlWindow, int maxMessageSize, int maxHeaderListSize,

long keepAliveTimeNanos, long keepAliveTimeoutNanos, boolean keepAliveWithoutCalls,

TransportTracer.Factory transportTracerFactory, LocalSocketPicker localSocketPicker,

boolean useGetForSafeMethods, Class<? extends SocketAddress> transportSocketType) {

Map<ChannelOption<?>, ?> channelOptions,

ObjectPool<? extends EventLoopGroup> groupPool,

boolean autoFlowControl,

int flowControlWindow,

int maxMessageSize,

int maxHeaderListSize,

int softLimitHeaderListSize,

long keepAliveTimeNanos,

long keepAliveTimeoutNanos,

boolean keepAliveWithoutCalls,

TransportTracer.Factory transportTracerFactory,

LocalSocketPicker localSocketPicker,

boolean useGetForSafeMethods,

Class<? extends SocketAddress> transportSocketType) {

this.protocolNegotiator = checkNotNull(protocolNegotiator, "protocolNegotiator");

this.channelFactory = channelFactory;

this.channelOptions = new HashMap<ChannelOption<?>, Object>(channelOptions);

this.flowControlWindow = flowControlWindow;

this.maxMessageSize = maxMessageSize;

this.maxHeaderListSize = maxHeaderListSize;

this.softLimitHeaderListSize = softLimitHeaderListSize;

this.keepAliveTimeNanos = keepAliveTimeNanos;

this.keepAliveBackoff = new AtomicBackoff("keepalive time nanos", keepAliveTimeNanos);

this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;

};

// TODO(carl-mastrangelo): Pass channelLogger in.

NettyClientTransport transport = new NettyClientTransport(

serverAddress, channelFactory, channelOptions, group,

localNegotiator, autoFlowControl, flowControlWindow,

maxMessageSize, maxHeaderListSize, keepAliveTimeNanosState.get(), keepAliveTimeoutNanos,

keepAliveWithoutCalls, options.getAuthority(), options.getUserAgent(),

tooManyPingsRunnable, transportTracerFactory.create(), options.getEagAttributes(),

localSocketPicker, channelLogger, useGetForSafeMethods, Ticker.systemTicker());

NettyClientTransport transport =

new NettyClientTransport(

serverAddress,

channelFactory,

channelOptions,

group,

localNegotiator,

autoFlowControl,

flowControlWindow,

maxMessageSize,

maxHeaderListSize,

softLimitHeaderListSize,

keepAliveTimeNanosState.get(),

keepAliveTimeoutNanos,

keepAliveWithoutCalls,

options.getAuthority(),

options.getUserAgent(),

tooManyPingsRunnable,

transportTracerFactory.create(),

options.getEagAttributes(),

localSocketPicker,

channelLogger,

useGetForSafeMethods,

Ticker.systemTicker());

return transport;

}

if (result.error != null) {

return null;

}

ClientTransportFactory factory = new NettyTransportFactory(

result.negotiator.newNegotiator(), channelFactory, channelOptions, groupPool,

autoFlowControl, flowControlWindow, maxMessageSize, maxHeaderListSize, keepAliveTimeNanos,

keepAliveTimeoutNanos, keepAliveWithoutCalls, transportTracerFactory, localSocketPicker,

useGetForSafeMethods, transportSocketType);

ClientTransportFactory factory =

new NettyTransportFactory(

result.negotiator.newNegotiator(),

channelFactory,

channelOptions,

groupPool,

autoFlowControl,

flowControlWindow,

maxMessageSize,

maxHeaderListSize,

softLimitHeaderListSize,

keepAliveTimeNanos,

keepAliveTimeoutNanos,

keepAliveWithoutCalls,

transportTracerFactory,

localSocketPicker,

useGetForSafeMethods,

transportSocketType);

return new SwapChannelCredentialsResult(factory, result.callCredentials);

}