/*
 * Copyright (c) 2011-2019 Contributors to the Eclipse Foundation
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 * which is available at https://www.apache.org/licenses/LICENSE-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 */

package io.vertx.core.http;

import io.netty.handler.codec.http2.Http2CodecUtil;
import io.vertx.codegen.annotations.DataObject;
import io.vertx.codegen.annotations.GenIgnore;
import io.vertx.core.impl.Arguments;
import io.vertx.core.json.JsonObject;

import java.util.HashMap;
import java.util.Map;

HTTP2 settings, the settings is initialized with the default HTTP/2 values.

The settings expose the parameters defined by the HTTP/2 specification, as well as extra settings for protocol extensions.

Author:Julien Viet
/** * HTTP2 settings, the settings is initialized with the default HTTP/2 values.<p> * * The settings expose the parameters defined by the HTTP/2 specification, as well as extra settings for * protocol extensions. * * @author <a href="mailto:julien@julienviet.com">Julien Viet</a> */
@DataObject(generateConverter = true, publicConverter = false) public class Http2Settings {
Default HTTP/2 spec value for getHeaderTableSize : 4096
/** * Default HTTP/2 spec value for {@link #getHeaderTableSize} : {@code 4096} */
public static final long DEFAULT_HEADER_TABLE_SIZE = 4096;
Default HTTP/2 spec value for isPushEnabled : true
/** * Default HTTP/2 spec value for {@link #isPushEnabled} : {@code true} */
public static final boolean DEFAULT_ENABLE_PUSH = true;
Default HTTP/2 spec value for getMaxConcurrentStreams : 0xFFFFFFFFL
/** * Default HTTP/2 spec value for {@link #getMaxConcurrentStreams} : {@code 0xFFFFFFFFL} */
public static final long DEFAULT_MAX_CONCURRENT_STREAMS = 0xFFFFFFFFL;
Default HTTP/2 spec value for getInitialWindowSize : 65535
/** * Default HTTP/2 spec value for {@link #getInitialWindowSize} : {@code 65535} */
public static final int DEFAULT_INITIAL_WINDOW_SIZE = 65535;
Default HTTP/2 spec value for getMaxFrameSize : 16384
/** * Default HTTP/2 spec value for {@link #getMaxFrameSize} : {@code 16384} */
public static final int DEFAULT_MAX_FRAME_SIZE = 16384;
Default HTTP/2 spec value for getMaxHeaderListSize : Integer.MAX_VALUE
/** * Default HTTP/2 spec value for {@link #getMaxHeaderListSize} : {@code Integer.MAX_VALUE} */
public static final int DEFAULT_MAX_HEADER_LIST_SIZE = Integer.MAX_VALUE;
Default HTTP/2 spec value for getExtraSettings : null
/** * Default HTTP/2 spec value for {@link #getExtraSettings} : {@code null} */
public static final Map<Integer, Long> DEFAULT_EXTRA_SETTINGS = null; private long headerTableSize; private boolean pushEnabled; private long maxConcurrentStreams; private int initialWindowSize; private int maxFrameSize; private long maxHeaderListSize; private Map<Integer, Long> extraSettings;
Default constructor
/** * Default constructor */
public Http2Settings() { headerTableSize = DEFAULT_HEADER_TABLE_SIZE; pushEnabled = DEFAULT_ENABLE_PUSH; maxConcurrentStreams = DEFAULT_MAX_CONCURRENT_STREAMS; initialWindowSize = DEFAULT_INITIAL_WINDOW_SIZE; maxFrameSize = DEFAULT_MAX_FRAME_SIZE; maxHeaderListSize = DEFAULT_MAX_HEADER_LIST_SIZE; extraSettings = DEFAULT_EXTRA_SETTINGS; }
Create an settings from JSON
Params:
  • json – the JSON
/** * Create an settings from JSON * * @param json the JSON */
public Http2Settings(JsonObject json) { this(); Http2SettingsConverter.fromJson(json, this); }
Copy constructor
Params:
  • other – the settings to copy
/** * Copy constructor * * @param other the settings to copy */
public Http2Settings(Http2Settings other) { headerTableSize = other.headerTableSize; pushEnabled = other.pushEnabled; maxConcurrentStreams = other.maxConcurrentStreams; initialWindowSize = other.initialWindowSize; maxFrameSize = other.maxFrameSize; maxHeaderListSize = other.maxHeaderListSize; extraSettings = other.extraSettings != null ? new HashMap<>(other.extraSettings) : null; }
Returns:the SETTINGS_HEADER_TABLE_SIZE HTTP/2 setting
/** * @return the {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting */
public long getHeaderTableSize() { return headerTableSize; }
Set SETTINGS_HEADER_TABLE_SIZE HTTP/2 setting.
Params:
  • headerTableSize – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set {@literal SETTINGS_HEADER_TABLE_SIZE} HTTP/2 setting. * * @param headerTableSize the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setHeaderTableSize(long headerTableSize) { Arguments.require(headerTableSize >= Http2CodecUtil.MIN_HEADER_TABLE_SIZE, "headerTableSize must be >= " + Http2CodecUtil.MIN_HEADER_TABLE_SIZE); Arguments.require(headerTableSize <= Http2CodecUtil.MAX_HEADER_TABLE_SIZE, "headerTableSize must be <= " + Http2CodecUtil.MAX_HEADER_TABLE_SIZE); this.headerTableSize = headerTableSize; return this; }
Returns:the SETTINGS_ENABLE_PUSH HTTP/2 setting
/** * @return the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting */
public boolean isPushEnabled() { return pushEnabled; }
Set the SETTINGS_ENABLE_PUSH HTTP/2 setting
Params:
  • pushEnabled – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set the {@literal SETTINGS_ENABLE_PUSH} HTTP/2 setting * * @param pushEnabled the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setPushEnabled(boolean pushEnabled) { this.pushEnabled = pushEnabled; return this; }
Returns:the SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting
/** * @return the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting */
public long getMaxConcurrentStreams() { return maxConcurrentStreams; }
Set the SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting
Params:
  • maxConcurrentStreams – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set the {@literal SETTINGS_MAX_CONCURRENT_STREAMS} HTTP/2 setting * * @param maxConcurrentStreams the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setMaxConcurrentStreams(long maxConcurrentStreams) { Arguments.require(maxConcurrentStreams >= Http2CodecUtil.MIN_CONCURRENT_STREAMS, "maxConcurrentStreams must be >= " + Http2CodecUtil.MIN_CONCURRENT_STREAMS); Arguments.require(maxConcurrentStreams <= Http2CodecUtil.MAX_CONCURRENT_STREAMS, "maxConcurrentStreams must be < " + Http2CodecUtil.MAX_CONCURRENT_STREAMS); this.maxConcurrentStreams = maxConcurrentStreams; return this; }
Returns:the SETTINGS_INITIAL_WINDOW_SIZE HTTP/2 setting
/** * @return the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting */
public int getInitialWindowSize() { return initialWindowSize; }
Set the SETTINGS_INITIAL_WINDOW_SIZE HTTP/2 setting
Params:
  • initialWindowSize – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set the {@literal SETTINGS_INITIAL_WINDOW_SIZE} HTTP/2 setting * * @param initialWindowSize the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setInitialWindowSize(int initialWindowSize) { Arguments.require(initialWindowSize >= Http2CodecUtil.MIN_INITIAL_WINDOW_SIZE, "initialWindowSize must be >= " + Http2CodecUtil.MIN_INITIAL_WINDOW_SIZE); this.initialWindowSize = initialWindowSize; return this; }
Returns:the SETTINGS_MAX_FRAME_SIZE HTTP/2 setting
/** * @return the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting */
public int getMaxFrameSize() { return maxFrameSize; }
Set the SETTINGS_MAX_FRAME_SIZE HTTP/2 setting
Params:
  • maxFrameSize – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set the {@literal SETTINGS_MAX_FRAME_SIZE} HTTP/2 setting * * @param maxFrameSize the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setMaxFrameSize(int maxFrameSize) { Arguments.require(maxFrameSize >= Http2CodecUtil.MAX_FRAME_SIZE_LOWER_BOUND, "maxFrameSize must be >= " + Http2CodecUtil.MAX_FRAME_SIZE_LOWER_BOUND); Arguments.require(maxFrameSize <= Http2CodecUtil.MAX_FRAME_SIZE_UPPER_BOUND, "maxFrameSize must be <= " + Http2CodecUtil.MAX_FRAME_SIZE_UPPER_BOUND); this.maxFrameSize = maxFrameSize; return this; }
Returns:the SETTINGS_MAX_HEADER_LIST_SIZE HTTP/2 setting
/** * @return the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting */
public long getMaxHeaderListSize() { return maxHeaderListSize; }
Set the SETTINGS_MAX_HEADER_LIST_SIZE HTTP/2 setting
Params:
  • maxHeaderListSize – the new value
Returns:a reference to this, so the API can be used fluently
/** * Set the {@literal SETTINGS_MAX_HEADER_LIST_SIZE} HTTP/2 setting * * @param maxHeaderListSize the new value * @return a reference to this, so the API can be used fluently */
public Http2Settings setMaxHeaderListSize(long maxHeaderListSize) { Arguments.require(maxHeaderListSize >= 0, "maxHeaderListSize must be >= 0"); Arguments.require(maxHeaderListSize >= Http2CodecUtil.MIN_HEADER_LIST_SIZE, "maxHeaderListSize must be >= " + Http2CodecUtil.MIN_HEADER_LIST_SIZE); this.maxHeaderListSize = maxHeaderListSize; return this; }
Returns:the extra settings used for extending HTTP/2
/** * @return the extra settings used for extending HTTP/2 */
@GenIgnore public Map<Integer, Long> getExtraSettings() { return extraSettings; }
Set the extra setting used for extending HTTP/2
Params:
  • settings – the new extra settings
Returns:a reference to this, so the API can be used fluently
/** * Set the extra setting used for extending HTTP/2 * * @param settings the new extra settings * @return a reference to this, so the API can be used fluently */
@GenIgnore public Http2Settings setExtraSettings(Map<Integer, Long> settings) { extraSettings = settings; return this; }
Return a setting value according to its identifier.
Params:
  • id – the setting identifier
Returns:the setting value
/** * Return a setting value according to its identifier. * * @param id the setting identifier * @return the setting value */
public Long get(int id) { switch (id) { case 1: return headerTableSize; case 2: return pushEnabled ? 1L : 0L; case 3: return maxConcurrentStreams; case 4: return (long)initialWindowSize; case 5: return (long)maxFrameSize; case 6: return (long)maxHeaderListSize; default: return extraSettings != null ? extraSettings.get(id) : null; } }
Set a setting value for a given setting id.
Params:
  • id – the setting id
  • value – the setting value
Returns:a reference to this, so the API can be used fluently
/** * Set a setting {@code value} for a given setting {@code id}. * * @param id the setting id * @param value the setting value * @return a reference to this, so the API can be used fluently */
public Http2Settings set(int id, long value) { Arguments.require(id >= 0 && id <= 0xFFFF, "Setting id must me an unsigned 16-bit value"); Arguments.require(value >= 0L && value <= 0xFFFFFFFFL, "Setting value must me an unsigned 32-bit value"); switch (id) { case 1: setHeaderTableSize(value); break; case 2: Arguments.require(value == 0 || value == 1, "enablePush must be 0 or 1"); setPushEnabled(value == 1); break; case 3: setMaxConcurrentStreams(value); break; case 4: setInitialWindowSize((int) value); break; case 5: setMaxFrameSize((int) value); break; case 6: Arguments.require(value <= Integer.MAX_VALUE, "maxHeaderListSize must be <= " + Integer.MAX_VALUE); setMaxHeaderListSize((int) value); break; default: if (extraSettings == null) { extraSettings = new HashMap<>(); } extraSettings.put(id, value); } return this; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Http2Settings that = (Http2Settings) o; if (headerTableSize != that.headerTableSize) return false; if (pushEnabled != that.pushEnabled) return false; if (maxConcurrentStreams != that.maxConcurrentStreams) return false; if (initialWindowSize != that.initialWindowSize) return false; if (maxFrameSize != that.maxFrameSize) return false; if (maxHeaderListSize != that.maxHeaderListSize) return false; return true; } @Override public int hashCode() { int result = (int) (headerTableSize ^ (headerTableSize >>> 32)); result = 31 * result + (pushEnabled ? 1 : 0); result = 31 * result + (int) (maxConcurrentStreams ^ (maxConcurrentStreams >>> 32)); result = 31 * result + initialWindowSize; result = 31 * result + maxFrameSize; result = 31 * result + (int) (maxHeaderListSize ^ (maxHeaderListSize >>> 32)); return result; } @Override public String toString() { return toJson().encode(); } public JsonObject toJson() { JsonObject json = new JsonObject(); Http2SettingsConverter.toJson(this, json); return json; } }