com.yahoo.jdisc.http.ConnectorConfig Maven / Gradle / Ivy
/**
* This file is generated from a config definition file.
* ------------ D O N O T E D I T ! ------------
*/
package com.yahoo.jdisc.http;
import java.util.*;
import java.io.File;
import java.nio.file.Path;
import com.yahoo.config.*;
/**
* This class represents the root node of connector
*
* Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
*/
public final class ConnectorConfig extends ConfigInstance {
public final static String CONFIG_DEF_MD5 = "44a30380ccaf69f4aac917afb58e95ea";
public final static String CONFIG_DEF_NAME = "connector";
public final static String CONFIG_DEF_NAMESPACE = "jdisc.http";
public final static String CONFIG_DEF_VERSION = "";
public final static String[] CONFIG_DEF_SCHEMA = {
"namespace=jdisc.http",
"listenPort int default=0",
"name string default=\"default\"",
"headerCacheSize int default=512",
"outputBufferSize int default=65536",
"requestHeaderSize int default=65536",
"responseHeaderSize int default=65536",
"acceptQueueSize int default=0",
"reuseAddress bool default=true",
"idleTimeout double default=180.0",
"stopTimeout double default = 30.0",
"tcpKeepAliveEnabled bool default=false",
"tcpNoDelay bool default=true",
"throttling.enabled bool default=false",
"throttling.maxConnections int default=-1",
"throttling.maxHeapUtilization double default=-1.0",
"throttling.maxAcceptRate int default=-1",
"throttling.idleTimeout double default=-1.0",
"implicitTlsEnabled bool default=true",
"ssl.enabled bool default=false",
"ssl.privateKeyFile string default=\"\"",
"ssl.privateKey string default=\"\"",
"ssl.certificateFile string default=\"\"",
"ssl.certificate string default=\"\"",
"ssl.caCertificateFile string default=\"\"",
"ssl.caCertificate string default=\"\"",
"ssl.clientAuth enum { DISABLED, WANT_AUTH, NEED_AUTH } default=DISABLED",
"ssl.enabledCipherSuites[] string",
"ssl.enabledProtocols[] string",
"tlsClientAuthEnforcer.enable bool default=false",
"tlsClientAuthEnforcer.pathWhitelist[] string",
"healthCheckProxy.enable bool default=false",
"healthCheckProxy.port int default=8080",
"healthCheckProxy.clientTimeout double default=1.0",
"proxyProtocol.enabled bool default=false",
"proxyProtocol.mixedMode bool default=false",
"secureRedirect.enabled bool default=false",
"secureRedirect.port int default=443",
"maxRequestsPerConnection int default=0",
"maxConnectionLife double default=0.0",
"http2Enabled bool default=true",
"http2.streamIdleTimeout double default=600",
"http2.maxConcurrentStreams int default=4096"
};
public static String getDefMd5() { return CONFIG_DEF_MD5; }
public static String getDefName() { return CONFIG_DEF_NAME; }
public static String getDefNamespace() { return CONFIG_DEF_NAMESPACE; }
public static String getDefVersion() { return CONFIG_DEF_VERSION; }
public interface Producer extends ConfigInstance.Producer {
void getConfig(Builder builder);
}
public static class Builder implements ConfigInstance.Builder {
private Set __uninitialized = new HashSet();
private Integer listenPort = null;
private String name = null;
private Integer headerCacheSize = null;
private Integer outputBufferSize = null;
private Integer requestHeaderSize = null;
private Integer responseHeaderSize = null;
private Integer acceptQueueSize = null;
private Boolean reuseAddress = null;
private Double idleTimeout = null;
private Double stopTimeout = null;
private Boolean tcpKeepAliveEnabled = null;
private Boolean tcpNoDelay = null;
public Throttling.Builder throttling = new Throttling.Builder();
private Boolean implicitTlsEnabled = null;
public Ssl.Builder ssl = new Ssl.Builder();
public TlsClientAuthEnforcer.Builder tlsClientAuthEnforcer = new TlsClientAuthEnforcer.Builder();
public HealthCheckProxy.Builder healthCheckProxy = new HealthCheckProxy.Builder();
public ProxyProtocol.Builder proxyProtocol = new ProxyProtocol.Builder();
public SecureRedirect.Builder secureRedirect = new SecureRedirect.Builder();
private Integer maxRequestsPerConnection = null;
private Double maxConnectionLife = null;
private Boolean http2Enabled = null;
public Http2.Builder http2 = new Http2.Builder();
public Builder() { }
public Builder(ConnectorConfig config) {
listenPort(config.listenPort());
name(config.name());
headerCacheSize(config.headerCacheSize());
outputBufferSize(config.outputBufferSize());
requestHeaderSize(config.requestHeaderSize());
responseHeaderSize(config.responseHeaderSize());
acceptQueueSize(config.acceptQueueSize());
reuseAddress(config.reuseAddress());
idleTimeout(config.idleTimeout());
stopTimeout(config.stopTimeout());
tcpKeepAliveEnabled(config.tcpKeepAliveEnabled());
tcpNoDelay(config.tcpNoDelay());
throttling(new Throttling.Builder(config.throttling()));
implicitTlsEnabled(config.implicitTlsEnabled());
ssl(new Ssl.Builder(config.ssl()));
tlsClientAuthEnforcer(new TlsClientAuthEnforcer.Builder(config.tlsClientAuthEnforcer()));
healthCheckProxy(new HealthCheckProxy.Builder(config.healthCheckProxy()));
proxyProtocol(new ProxyProtocol.Builder(config.proxyProtocol()));
secureRedirect(new SecureRedirect.Builder(config.secureRedirect()));
maxRequestsPerConnection(config.maxRequestsPerConnection());
maxConnectionLife(config.maxConnectionLife());
http2Enabled(config.http2Enabled());
http2(new Http2.Builder(config.http2()));
}
private Builder override(Builder __superior) {
if (__superior.listenPort != null)
listenPort(__superior.listenPort);
if (__superior.name != null)
name(__superior.name);
if (__superior.headerCacheSize != null)
headerCacheSize(__superior.headerCacheSize);
if (__superior.outputBufferSize != null)
outputBufferSize(__superior.outputBufferSize);
if (__superior.requestHeaderSize != null)
requestHeaderSize(__superior.requestHeaderSize);
if (__superior.responseHeaderSize != null)
responseHeaderSize(__superior.responseHeaderSize);
if (__superior.acceptQueueSize != null)
acceptQueueSize(__superior.acceptQueueSize);
if (__superior.reuseAddress != null)
reuseAddress(__superior.reuseAddress);
if (__superior.idleTimeout != null)
idleTimeout(__superior.idleTimeout);
if (__superior.stopTimeout != null)
stopTimeout(__superior.stopTimeout);
if (__superior.tcpKeepAliveEnabled != null)
tcpKeepAliveEnabled(__superior.tcpKeepAliveEnabled);
if (__superior.tcpNoDelay != null)
tcpNoDelay(__superior.tcpNoDelay);
throttling(throttling.override(__superior.throttling));
if (__superior.implicitTlsEnabled != null)
implicitTlsEnabled(__superior.implicitTlsEnabled);
ssl(ssl.override(__superior.ssl));
tlsClientAuthEnforcer(tlsClientAuthEnforcer.override(__superior.tlsClientAuthEnforcer));
healthCheckProxy(healthCheckProxy.override(__superior.healthCheckProxy));
proxyProtocol(proxyProtocol.override(__superior.proxyProtocol));
secureRedirect(secureRedirect.override(__superior.secureRedirect));
if (__superior.maxRequestsPerConnection != null)
maxRequestsPerConnection(__superior.maxRequestsPerConnection);
if (__superior.maxConnectionLife != null)
maxConnectionLife(__superior.maxConnectionLife);
if (__superior.http2Enabled != null)
http2Enabled(__superior.http2Enabled);
http2(http2.override(__superior.http2));
return this;
}
public Builder listenPort(int __value) {
listenPort = __value;
return this;
}
private Builder listenPort(String __value) {
return listenPort(Integer.valueOf(__value));
}
public Builder name(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
name = __value;
return this;
}
public Builder headerCacheSize(int __value) {
headerCacheSize = __value;
return this;
}
private Builder headerCacheSize(String __value) {
return headerCacheSize(Integer.valueOf(__value));
}
public Builder outputBufferSize(int __value) {
outputBufferSize = __value;
return this;
}
private Builder outputBufferSize(String __value) {
return outputBufferSize(Integer.valueOf(__value));
}
public Builder requestHeaderSize(int __value) {
requestHeaderSize = __value;
return this;
}
private Builder requestHeaderSize(String __value) {
return requestHeaderSize(Integer.valueOf(__value));
}
public Builder responseHeaderSize(int __value) {
responseHeaderSize = __value;
return this;
}
private Builder responseHeaderSize(String __value) {
return responseHeaderSize(Integer.valueOf(__value));
}
public Builder acceptQueueSize(int __value) {
acceptQueueSize = __value;
return this;
}
private Builder acceptQueueSize(String __value) {
return acceptQueueSize(Integer.valueOf(__value));
}
public Builder reuseAddress(boolean __value) {
reuseAddress = __value;
return this;
}
private Builder reuseAddress(String __value) {
return reuseAddress(Boolean.valueOf(__value));
}
public Builder idleTimeout(double __value) {
idleTimeout = __value;
return this;
}
private Builder idleTimeout(String __value) {
return idleTimeout(Double.valueOf(__value));
}
public Builder stopTimeout(double __value) {
stopTimeout = __value;
return this;
}
private Builder stopTimeout(String __value) {
return stopTimeout(Double.valueOf(__value));
}
public Builder tcpKeepAliveEnabled(boolean __value) {
tcpKeepAliveEnabled = __value;
return this;
}
private Builder tcpKeepAliveEnabled(String __value) {
return tcpKeepAliveEnabled(Boolean.valueOf(__value));
}
public Builder tcpNoDelay(boolean __value) {
tcpNoDelay = __value;
return this;
}
private Builder tcpNoDelay(String __value) {
return tcpNoDelay(Boolean.valueOf(__value));
}
public Builder throttling(Throttling.Builder __builder) {
throttling = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder throttling(java.util.function.Consumer __func) {
Throttling.Builder __inner = new Throttling.Builder();
__func.accept(__inner);
throttling = __inner;
return this;
}
public Builder implicitTlsEnabled(boolean __value) {
implicitTlsEnabled = __value;
return this;
}
private Builder implicitTlsEnabled(String __value) {
return implicitTlsEnabled(Boolean.valueOf(__value));
}
public Builder ssl(Ssl.Builder __builder) {
ssl = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder ssl(java.util.function.Consumer __func) {
Ssl.Builder __inner = new Ssl.Builder();
__func.accept(__inner);
ssl = __inner;
return this;
}
public Builder tlsClientAuthEnforcer(TlsClientAuthEnforcer.Builder __builder) {
tlsClientAuthEnforcer = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder tlsClientAuthEnforcer(java.util.function.Consumer __func) {
TlsClientAuthEnforcer.Builder __inner = new TlsClientAuthEnforcer.Builder();
__func.accept(__inner);
tlsClientAuthEnforcer = __inner;
return this;
}
public Builder healthCheckProxy(HealthCheckProxy.Builder __builder) {
healthCheckProxy = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder healthCheckProxy(java.util.function.Consumer __func) {
HealthCheckProxy.Builder __inner = new HealthCheckProxy.Builder();
__func.accept(__inner);
healthCheckProxy = __inner;
return this;
}
public Builder proxyProtocol(ProxyProtocol.Builder __builder) {
proxyProtocol = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder proxyProtocol(java.util.function.Consumer __func) {
ProxyProtocol.Builder __inner = new ProxyProtocol.Builder();
__func.accept(__inner);
proxyProtocol = __inner;
return this;
}
public Builder secureRedirect(SecureRedirect.Builder __builder) {
secureRedirect = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder secureRedirect(java.util.function.Consumer __func) {
SecureRedirect.Builder __inner = new SecureRedirect.Builder();
__func.accept(__inner);
secureRedirect = __inner;
return this;
}
public Builder maxRequestsPerConnection(int __value) {
maxRequestsPerConnection = __value;
return this;
}
private Builder maxRequestsPerConnection(String __value) {
return maxRequestsPerConnection(Integer.valueOf(__value));
}
public Builder maxConnectionLife(double __value) {
maxConnectionLife = __value;
return this;
}
private Builder maxConnectionLife(String __value) {
return maxConnectionLife(Double.valueOf(__value));
}
public Builder http2Enabled(boolean __value) {
http2Enabled = __value;
return this;
}
private Builder http2Enabled(String __value) {
return http2Enabled(Boolean.valueOf(__value));
}
public Builder http2(Http2.Builder __builder) {
http2 = __builder;
return this;
}
/**
* Make a new builder and run the supplied function on it before adding it to the list
* @param __func lambda that modifies the given builder
* @return this builder
*/
public Builder http2(java.util.function.Consumer __func) {
Http2.Builder __inner = new Http2.Builder();
__func.accept(__inner);
http2 = __inner;
return this;
}
private boolean _applyOnRestart = false;
@java.lang.Override
public final boolean dispatchGetConfig(ConfigInstance.Producer producer) {
if (producer instanceof Producer) {
((Producer)producer).getConfig(this);
return true;
}
return false;
}
@java.lang.Override
public final String getDefMd5() { return CONFIG_DEF_MD5; }
@java.lang.Override
public final String getDefName() { return CONFIG_DEF_NAME; }
@java.lang.Override
public final String getDefNamespace() { return CONFIG_DEF_NAMESPACE; }
@java.lang.Override
public final boolean getApplyOnRestart() { return _applyOnRestart; }
@java.lang.Override
public final void setApplyOnRestart(boolean applyOnRestart) { _applyOnRestart = applyOnRestart; }
public ConnectorConfig build() {
return new ConnectorConfig(this);
}
}
// The TCP port to listen to for this connector.
private final IntegerNode listenPort;
// The connector name
private final StringNode name;
// The header field cache size.
private final IntegerNode headerCacheSize;
// The size of the buffer into which response content is aggregated before being sent to the client.
private final IntegerNode outputBufferSize;
// The maximum size of a request header.
private final IntegerNode requestHeaderSize;
// The maximum size of a response header.
private final IntegerNode responseHeaderSize;
// The accept queue size (also known as accept backlog).
private final IntegerNode acceptQueueSize;
// Whether the server socket reuses addresses.
private final BooleanNode reuseAddress;
// The maximum idle time for a connection, which roughly translates to the Socket.setSoTimeout(int).
private final DoubleNode idleTimeout;
// DEPRECATED - Ignored, no longer in use
private final DoubleNode stopTimeout;
// TODO Vespa 8 Remove stop timeout
// Whether or not to have socket keep alive turned on.
private final BooleanNode tcpKeepAliveEnabled;
// Enable/disable TCP_NODELAY (disable/enable Nagle's algorithm).
private final BooleanNode tcpNoDelay;
private final Throttling throttling;
// Whether to enable TLS on connector when Vespa is configured with TLS.
// The connector will implicitly enable TLS if set to 'true' and Vespa TLS is enabled.
private final BooleanNode implicitTlsEnabled;
private final Ssl ssl;
private final TlsClientAuthEnforcer tlsClientAuthEnforcer;
private final HealthCheckProxy healthCheckProxy;
private final ProxyProtocol proxyProtocol;
private final SecureRedirect secureRedirect;
// Maximum number of request per connection before server marks connections as non-persistent. Set to '0' to disable.
private final IntegerNode maxRequestsPerConnection;
// Maximum number of seconds a connection can live before it's marked as non-persistent. Set to '0' to disable.
private final DoubleNode maxConnectionLife;
// Enable HTTP/2 (in addition to HTTP/1.1 using ALPN)
private final BooleanNode http2Enabled;
private final Http2 http2;
public ConnectorConfig(Builder builder) {
this(builder, true);
}
private ConnectorConfig(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector must be initialized: " + builder.__uninitialized);
listenPort = (builder.listenPort == null) ?
new IntegerNode(0) : new IntegerNode(builder.listenPort);
name = (builder.name == null) ?
new StringNode("default") : new StringNode(builder.name);
headerCacheSize = (builder.headerCacheSize == null) ?
new IntegerNode(512) : new IntegerNode(builder.headerCacheSize);
outputBufferSize = (builder.outputBufferSize == null) ?
new IntegerNode(65536) : new IntegerNode(builder.outputBufferSize);
requestHeaderSize = (builder.requestHeaderSize == null) ?
new IntegerNode(65536) : new IntegerNode(builder.requestHeaderSize);
responseHeaderSize = (builder.responseHeaderSize == null) ?
new IntegerNode(65536) : new IntegerNode(builder.responseHeaderSize);
acceptQueueSize = (builder.acceptQueueSize == null) ?
new IntegerNode(0) : new IntegerNode(builder.acceptQueueSize);
reuseAddress = (builder.reuseAddress == null) ?
new BooleanNode(true) : new BooleanNode(builder.reuseAddress);
idleTimeout = (builder.idleTimeout == null) ?
new DoubleNode(180.0D) : new DoubleNode(builder.idleTimeout);
stopTimeout = (builder.stopTimeout == null) ?
new DoubleNode(30.0D) : new DoubleNode(builder.stopTimeout);
tcpKeepAliveEnabled = (builder.tcpKeepAliveEnabled == null) ?
new BooleanNode(false) : new BooleanNode(builder.tcpKeepAliveEnabled);
tcpNoDelay = (builder.tcpNoDelay == null) ?
new BooleanNode(true) : new BooleanNode(builder.tcpNoDelay);
throttling = new Throttling(builder.throttling, throwIfUninitialized);
implicitTlsEnabled = (builder.implicitTlsEnabled == null) ?
new BooleanNode(true) : new BooleanNode(builder.implicitTlsEnabled);
ssl = new Ssl(builder.ssl, throwIfUninitialized);
tlsClientAuthEnforcer = new TlsClientAuthEnforcer(builder.tlsClientAuthEnforcer, throwIfUninitialized);
healthCheckProxy = new HealthCheckProxy(builder.healthCheckProxy, throwIfUninitialized);
proxyProtocol = new ProxyProtocol(builder.proxyProtocol, throwIfUninitialized);
secureRedirect = new SecureRedirect(builder.secureRedirect, throwIfUninitialized);
maxRequestsPerConnection = (builder.maxRequestsPerConnection == null) ?
new IntegerNode(0) : new IntegerNode(builder.maxRequestsPerConnection);
maxConnectionLife = (builder.maxConnectionLife == null) ?
new DoubleNode(0.0D) : new DoubleNode(builder.maxConnectionLife);
http2Enabled = (builder.http2Enabled == null) ?
new BooleanNode(true) : new BooleanNode(builder.http2Enabled);
http2 = new Http2(builder.http2, throwIfUninitialized);
}
/**
* @return connector.listenPort
*/
public int listenPort() {
return listenPort.value();
}
/**
* @return connector.name
*/
public String name() {
return name.value();
}
/**
* @return connector.headerCacheSize
*/
public int headerCacheSize() {
return headerCacheSize.value();
}
/**
* @return connector.outputBufferSize
*/
public int outputBufferSize() {
return outputBufferSize.value();
}
/**
* @return connector.requestHeaderSize
*/
public int requestHeaderSize() {
return requestHeaderSize.value();
}
/**
* @return connector.responseHeaderSize
*/
public int responseHeaderSize() {
return responseHeaderSize.value();
}
/**
* @return connector.acceptQueueSize
*/
public int acceptQueueSize() {
return acceptQueueSize.value();
}
/**
* @return connector.reuseAddress
*/
public boolean reuseAddress() {
return reuseAddress.value();
}
/**
* @return connector.idleTimeout
*/
public double idleTimeout() {
return idleTimeout.value();
}
/**
* @return connector.stopTimeout
*/
public double stopTimeout() {
return stopTimeout.value();
}
/**
* @return connector.tcpKeepAliveEnabled
*/
public boolean tcpKeepAliveEnabled() {
return tcpKeepAliveEnabled.value();
}
/**
* @return connector.tcpNoDelay
*/
public boolean tcpNoDelay() {
return tcpNoDelay.value();
}
/**
* @return connector.throttling
*/
public Throttling throttling() {
return throttling;
}
/**
* @return connector.implicitTlsEnabled
*/
public boolean implicitTlsEnabled() {
return implicitTlsEnabled.value();
}
/**
* @return connector.ssl
*/
public Ssl ssl() {
return ssl;
}
/**
* @return connector.tlsClientAuthEnforcer
*/
public TlsClientAuthEnforcer tlsClientAuthEnforcer() {
return tlsClientAuthEnforcer;
}
/**
* @return connector.healthCheckProxy
*/
public HealthCheckProxy healthCheckProxy() {
return healthCheckProxy;
}
/**
* @return connector.proxyProtocol
*/
public ProxyProtocol proxyProtocol() {
return proxyProtocol;
}
/**
* @return connector.secureRedirect
*/
public SecureRedirect secureRedirect() {
return secureRedirect;
}
/**
* @return connector.maxRequestsPerConnection
*/
public int maxRequestsPerConnection() {
return maxRequestsPerConnection.value();
}
/**
* @return connector.maxConnectionLife
*/
public double maxConnectionLife() {
return maxConnectionLife.value();
}
/**
* @return connector.http2Enabled
*/
public boolean http2Enabled() {
return http2Enabled.value();
}
/**
* @return connector.http2
*/
public Http2 http2() {
return http2;
}
private ChangesRequiringRestart getChangesRequiringRestart(ConnectorConfig newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("connector");
return changes;
}
private static boolean containsFieldsFlaggedWithRestart() {
return false;
}
/**
* This class represents connector.throttling
*/
public final static class Throttling extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enabled = null;
private Integer maxConnections = null;
private Double maxHeapUtilization = null;
private Integer maxAcceptRate = null;
private Double idleTimeout = null;
public Builder() { }
public Builder(Throttling config) {
enabled(config.enabled());
maxConnections(config.maxConnections());
maxHeapUtilization(config.maxHeapUtilization());
maxAcceptRate(config.maxAcceptRate());
idleTimeout(config.idleTimeout());
}
private Builder override(Builder __superior) {
if (__superior.enabled != null)
enabled(__superior.enabled);
if (__superior.maxConnections != null)
maxConnections(__superior.maxConnections);
if (__superior.maxHeapUtilization != null)
maxHeapUtilization(__superior.maxHeapUtilization);
if (__superior.maxAcceptRate != null)
maxAcceptRate(__superior.maxAcceptRate);
if (__superior.idleTimeout != null)
idleTimeout(__superior.idleTimeout);
return this;
}
public Builder enabled(boolean __value) {
enabled = __value;
return this;
}
private Builder enabled(String __value) {
return enabled(Boolean.valueOf(__value));
}
public Builder maxConnections(int __value) {
maxConnections = __value;
return this;
}
private Builder maxConnections(String __value) {
return maxConnections(Integer.valueOf(__value));
}
public Builder maxHeapUtilization(double __value) {
maxHeapUtilization = __value;
return this;
}
private Builder maxHeapUtilization(String __value) {
return maxHeapUtilization(Double.valueOf(__value));
}
public Builder maxAcceptRate(int __value) {
maxAcceptRate = __value;
return this;
}
private Builder maxAcceptRate(String __value) {
return maxAcceptRate(Integer.valueOf(__value));
}
public Builder idleTimeout(double __value) {
idleTimeout = __value;
return this;
}
private Builder idleTimeout(String __value) {
return idleTimeout(Double.valueOf(__value));
}
public Throttling build() {
return new Throttling(this);
}
}
// Whether to enable connection throttling. New connections will be dropped when a threshold is exceeded.
private final BooleanNode enabled;
// Max number of connections.
private final IntegerNode maxConnections;
// Max memory utilization as a value between 0 and 1.
private final DoubleNode maxHeapUtilization;
// Max connection accept rate per second.
private final IntegerNode maxAcceptRate;
// Idle timeout in seconds applied to endpoints when a threshold is exceeded.
private final DoubleNode idleTimeout;
public Throttling(Builder builder) {
this(builder, true);
}
private Throttling(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.throttling must be initialized: " + builder.__uninitialized);
enabled = (builder.enabled == null) ?
new BooleanNode(false) : new BooleanNode(builder.enabled);
maxConnections = (builder.maxConnections == null) ?
new IntegerNode(-1) : new IntegerNode(builder.maxConnections);
maxHeapUtilization = (builder.maxHeapUtilization == null) ?
new DoubleNode(-1.0D) : new DoubleNode(builder.maxHeapUtilization);
maxAcceptRate = (builder.maxAcceptRate == null) ?
new IntegerNode(-1) : new IntegerNode(builder.maxAcceptRate);
idleTimeout = (builder.idleTimeout == null) ?
new DoubleNode(-1.0D) : new DoubleNode(builder.idleTimeout);
}
/**
* @return connector.throttling.enabled
*/
public boolean enabled() {
return enabled.value();
}
/**
* @return connector.throttling.maxConnections
*/
public int maxConnections() {
return maxConnections.value();
}
/**
* @return connector.throttling.maxHeapUtilization
*/
public double maxHeapUtilization() {
return maxHeapUtilization.value();
}
/**
* @return connector.throttling.maxAcceptRate
*/
public int maxAcceptRate() {
return maxAcceptRate.value();
}
/**
* @return connector.throttling.idleTimeout
*/
public double idleTimeout() {
return idleTimeout.value();
}
private ChangesRequiringRestart getChangesRequiringRestart(Throttling newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("throttling");
return changes;
}
}
/**
* This class represents connector.ssl
*/
public final static class Ssl extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enabled = null;
private String privateKeyFile = null;
private String privateKey = null;
private String certificateFile = null;
private String certificate = null;
private String caCertificateFile = null;
private String caCertificate = null;
private ClientAuth.Enum clientAuth = null;
public List enabledCipherSuites = new ArrayList<>();
public List enabledProtocols = new ArrayList<>();
public Builder() { }
public Builder(Ssl config) {
enabled(config.enabled());
privateKeyFile(config.privateKeyFile());
privateKey(config.privateKey());
certificateFile(config.certificateFile());
certificate(config.certificate());
caCertificateFile(config.caCertificateFile());
caCertificate(config.caCertificate());
clientAuth(config.clientAuth());
enabledCipherSuites(config.enabledCipherSuites());
enabledProtocols(config.enabledProtocols());
}
private Builder override(Builder __superior) {
if (__superior.enabled != null)
enabled(__superior.enabled);
if (__superior.privateKeyFile != null)
privateKeyFile(__superior.privateKeyFile);
if (__superior.privateKey != null)
privateKey(__superior.privateKey);
if (__superior.certificateFile != null)
certificateFile(__superior.certificateFile);
if (__superior.certificate != null)
certificate(__superior.certificate);
if (__superior.caCertificateFile != null)
caCertificateFile(__superior.caCertificateFile);
if (__superior.caCertificate != null)
caCertificate(__superior.caCertificate);
if (__superior.clientAuth != null)
clientAuth(__superior.clientAuth);
if (!__superior.enabledCipherSuites.isEmpty())
enabledCipherSuites.addAll(__superior.enabledCipherSuites);
if (!__superior.enabledProtocols.isEmpty())
enabledProtocols.addAll(__superior.enabledProtocols);
return this;
}
public Builder enabled(boolean __value) {
enabled = __value;
return this;
}
private Builder enabled(String __value) {
return enabled(Boolean.valueOf(__value));
}
public Builder privateKeyFile(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
privateKeyFile = __value;
return this;
}
public Builder privateKey(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
privateKey = __value;
return this;
}
public Builder certificateFile(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
certificateFile = __value;
return this;
}
public Builder certificate(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
certificate = __value;
return this;
}
public Builder caCertificateFile(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
caCertificateFile = __value;
return this;
}
public Builder caCertificate(String __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
caCertificate = __value;
return this;
}
public Builder clientAuth(ClientAuth.Enum __value) {
if (__value == null) throw new IllegalArgumentException("Null value is not allowed.");
clientAuth = __value;
return this;
}
private Builder clientAuth(String __value) {
return clientAuth(ClientAuth.Enum.valueOf(__value));
}
public Builder enabledCipherSuites(String __value) {
enabledCipherSuites.add(__value);
return this;
}
public Builder enabledCipherSuites(Collection __values) {
enabledCipherSuites.addAll(__values);
return this;
}
public Builder enabledProtocols(String __value) {
enabledProtocols.add(__value);
return this;
}
public Builder enabledProtocols(Collection __values) {
enabledProtocols.addAll(__values);
return this;
}
public Ssl build() {
return new Ssl(this);
}
}
// Whether to enable SSL for this connector.
private final BooleanNode enabled;
// File with private key in PEM format. Specify either this or privateKey, but not both
private final StringNode privateKeyFile;
// Private key in PEM format. Specify either this or privateKeyFile, but not both
private final StringNode privateKey;
// File with certificate in PEM format. Specify either this or certificate, but not both
private final StringNode certificateFile;
// Certificate in PEM format. Specify either this or certificateFile, but not both
private final StringNode certificate;
// with trusted CA certificates in PEM format. Used to verify clients
// - this is the name of a file on the local container file system
// - only one of caCertificateFile and caCertificate
private final StringNode caCertificateFile;
// with trusted CA certificates in PEM format. Used to verify clients
// - this is the actual certificates instead of a pointer to the file
// - only one of caCertificateFile and caCertificate
private final StringNode caCertificate;
// Client authentication mode. See SSLEngine.getNeedClientAuth()/getWantClientAuth() for details.
private final ClientAuth clientAuth;
// List of enabled cipher suites. JDisc will use Vespa default if empty.
private final LeafNodeVector enabledCipherSuites;
// List of enabled TLS protocol versions. JDisc will use Vespa default if empty.
private final LeafNodeVector enabledProtocols;
public Ssl(Builder builder) {
this(builder, true);
}
private Ssl(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.ssl must be initialized: " + builder.__uninitialized);
enabled = (builder.enabled == null) ?
new BooleanNode(false) : new BooleanNode(builder.enabled);
privateKeyFile = (builder.privateKeyFile == null) ?
new StringNode("") : new StringNode(builder.privateKeyFile);
privateKey = (builder.privateKey == null) ?
new StringNode("") : new StringNode(builder.privateKey);
certificateFile = (builder.certificateFile == null) ?
new StringNode("") : new StringNode(builder.certificateFile);
certificate = (builder.certificate == null) ?
new StringNode("") : new StringNode(builder.certificate);
caCertificateFile = (builder.caCertificateFile == null) ?
new StringNode("") : new StringNode(builder.caCertificateFile);
caCertificate = (builder.caCertificate == null) ?
new StringNode("") : new StringNode(builder.caCertificate);
clientAuth = (builder.clientAuth == null) ?
new ClientAuth(ClientAuth.DISABLED) : new ClientAuth(builder.clientAuth);
enabledCipherSuites = new LeafNodeVector<>(builder.enabledCipherSuites, new StringNode());
enabledProtocols = new LeafNodeVector<>(builder.enabledProtocols, new StringNode());
}
/**
* @return connector.ssl.enabled
*/
public boolean enabled() {
return enabled.value();
}
/**
* @return connector.ssl.privateKeyFile
*/
public String privateKeyFile() {
return privateKeyFile.value();
}
/**
* @return connector.ssl.privateKey
*/
public String privateKey() {
return privateKey.value();
}
/**
* @return connector.ssl.certificateFile
*/
public String certificateFile() {
return certificateFile.value();
}
/**
* @return connector.ssl.certificate
*/
public String certificate() {
return certificate.value();
}
/**
* @return connector.ssl.caCertificateFile
*/
public String caCertificateFile() {
return caCertificateFile.value();
}
/**
* @return connector.ssl.caCertificate
*/
public String caCertificate() {
return caCertificate.value();
}
/**
* @return connector.ssl.clientAuth
*/
public ClientAuth.Enum clientAuth() {
return clientAuth.value();
}
/**
* @return connector.ssl.enabledCipherSuites[]
*/
public List enabledCipherSuites() {
return enabledCipherSuites.asList();
}
/**
* @param i the index of the value to return
* @return connector.ssl.enabledCipherSuites[]
*/
public String enabledCipherSuites(int i) {
return enabledCipherSuites.get(i).value();
}
/**
* @return connector.ssl.enabledProtocols[]
*/
public List enabledProtocols() {
return enabledProtocols.asList();
}
/**
* @param i the index of the value to return
* @return connector.ssl.enabledProtocols[]
*/
public String enabledProtocols(int i) {
return enabledProtocols.get(i).value();
}
private ChangesRequiringRestart getChangesRequiringRestart(Ssl newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("ssl");
return changes;
}
/**
* This class represents connector.ssl.clientAuth
*
* Client authentication mode. See SSLEngine.getNeedClientAuth()/getWantClientAuth() for details.
*/
public final static class ClientAuth extends EnumNode {
public ClientAuth(){
this.value = null;
}
public ClientAuth(Enum enumValue) {
super(enumValue != null);
this.value = enumValue;
}
public enum Enum {DISABLED, WANT_AUTH, NEED_AUTH}
public final static Enum DISABLED = Enum.DISABLED;
public final static Enum WANT_AUTH = Enum.WANT_AUTH;
public final static Enum NEED_AUTH = Enum.NEED_AUTH;
@Override
protected boolean doSetValue(String name) {
try {
value = Enum.valueOf(name);
return true;
} catch (IllegalArgumentException e) {
}
return false;
}
}
}
/**
* This class represents connector.tlsClientAuthEnforcer
*/
public final static class TlsClientAuthEnforcer extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enable = null;
public List pathWhitelist = new ArrayList<>();
public Builder() { }
public Builder(TlsClientAuthEnforcer config) {
enable(config.enable());
pathWhitelist(config.pathWhitelist());
}
private Builder override(Builder __superior) {
if (__superior.enable != null)
enable(__superior.enable);
if (!__superior.pathWhitelist.isEmpty())
pathWhitelist.addAll(__superior.pathWhitelist);
return this;
}
public Builder enable(boolean __value) {
enable = __value;
return this;
}
private Builder enable(String __value) {
return enable(Boolean.valueOf(__value));
}
public Builder pathWhitelist(String __value) {
pathWhitelist.add(__value);
return this;
}
public Builder pathWhitelist(Collection __values) {
pathWhitelist.addAll(__values);
return this;
}
public TlsClientAuthEnforcer build() {
return new TlsClientAuthEnforcer(this);
}
}
// Enforce TLS client authentication for https requests at the http layer.
// Intended to be used with connectors with optional client authentication enabled.
// 401 status code is returned for requests from non-authenticated clients.
private final BooleanNode enable;
// Paths where client authentication should not be enforced. To be used in combination with WANT_AUTH. Typically used for health checks.
private final LeafNodeVector pathWhitelist;
public TlsClientAuthEnforcer(Builder builder) {
this(builder, true);
}
private TlsClientAuthEnforcer(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.tlsClientAuthEnforcer must be initialized: " + builder.__uninitialized);
enable = (builder.enable == null) ?
new BooleanNode(false) : new BooleanNode(builder.enable);
pathWhitelist = new LeafNodeVector<>(builder.pathWhitelist, new StringNode());
}
/**
* @return connector.tlsClientAuthEnforcer.enable
*/
public boolean enable() {
return enable.value();
}
/**
* @return connector.tlsClientAuthEnforcer.pathWhitelist[]
*/
public List pathWhitelist() {
return pathWhitelist.asList();
}
/**
* @param i the index of the value to return
* @return connector.tlsClientAuthEnforcer.pathWhitelist[]
*/
public String pathWhitelist(int i) {
return pathWhitelist.get(i).value();
}
private ChangesRequiringRestart getChangesRequiringRestart(TlsClientAuthEnforcer newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("tlsClientAuthEnforcer");
return changes;
}
}
/**
* This class represents connector.healthCheckProxy
*/
public final static class HealthCheckProxy extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enable = null;
private Integer port = null;
private Double clientTimeout = null;
public Builder() { }
public Builder(HealthCheckProxy config) {
enable(config.enable());
port(config.port());
clientTimeout(config.clientTimeout());
}
private Builder override(Builder __superior) {
if (__superior.enable != null)
enable(__superior.enable);
if (__superior.port != null)
port(__superior.port);
if (__superior.clientTimeout != null)
clientTimeout(__superior.clientTimeout);
return this;
}
public Builder enable(boolean __value) {
enable = __value;
return this;
}
private Builder enable(String __value) {
return enable(Boolean.valueOf(__value));
}
public Builder port(int __value) {
port = __value;
return this;
}
private Builder port(String __value) {
return port(Integer.valueOf(__value));
}
public Builder clientTimeout(double __value) {
clientTimeout = __value;
return this;
}
private Builder clientTimeout(String __value) {
return clientTimeout(Double.valueOf(__value));
}
public HealthCheckProxy build() {
return new HealthCheckProxy(this);
}
}
// Use connector only for proxying '/status.html' health checks. Any ssl configuration will be ignored if this option is enabled.
private final BooleanNode enable;
// Which port to proxy
private final IntegerNode port;
// Low-level timeout for proxy client (socket connect, socket read, connection pool). Aggregate timeout will be longer.
private final DoubleNode clientTimeout;
public HealthCheckProxy(Builder builder) {
this(builder, true);
}
private HealthCheckProxy(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.healthCheckProxy must be initialized: " + builder.__uninitialized);
enable = (builder.enable == null) ?
new BooleanNode(false) : new BooleanNode(builder.enable);
port = (builder.port == null) ?
new IntegerNode(8080) : new IntegerNode(builder.port);
clientTimeout = (builder.clientTimeout == null) ?
new DoubleNode(1.0D) : new DoubleNode(builder.clientTimeout);
}
/**
* @return connector.healthCheckProxy.enable
*/
public boolean enable() {
return enable.value();
}
/**
* @return connector.healthCheckProxy.port
*/
public int port() {
return port.value();
}
/**
* @return connector.healthCheckProxy.clientTimeout
*/
public double clientTimeout() {
return clientTimeout.value();
}
private ChangesRequiringRestart getChangesRequiringRestart(HealthCheckProxy newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("healthCheckProxy");
return changes;
}
}
/**
* This class represents connector.proxyProtocol
*/
public final static class ProxyProtocol extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enabled = null;
private Boolean mixedMode = null;
public Builder() { }
public Builder(ProxyProtocol config) {
enabled(config.enabled());
mixedMode(config.mixedMode());
}
private Builder override(Builder __superior) {
if (__superior.enabled != null)
enabled(__superior.enabled);
if (__superior.mixedMode != null)
mixedMode(__superior.mixedMode);
return this;
}
public Builder enabled(boolean __value) {
enabled = __value;
return this;
}
private Builder enabled(String __value) {
return enabled(Boolean.valueOf(__value));
}
public Builder mixedMode(boolean __value) {
mixedMode = __value;
return this;
}
private Builder mixedMode(String __value) {
return mixedMode(Boolean.valueOf(__value));
}
public ProxyProtocol build() {
return new ProxyProtocol(this);
}
}
// Enable PROXY protocol V1/V2 support (only for https connectors).
private final BooleanNode enabled;
// Allow https in parallel with proxy protocol
private final BooleanNode mixedMode;
public ProxyProtocol(Builder builder) {
this(builder, true);
}
private ProxyProtocol(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.proxyProtocol must be initialized: " + builder.__uninitialized);
enabled = (builder.enabled == null) ?
new BooleanNode(false) : new BooleanNode(builder.enabled);
mixedMode = (builder.mixedMode == null) ?
new BooleanNode(false) : new BooleanNode(builder.mixedMode);
}
/**
* @return connector.proxyProtocol.enabled
*/
public boolean enabled() {
return enabled.value();
}
/**
* @return connector.proxyProtocol.mixedMode
*/
public boolean mixedMode() {
return mixedMode.value();
}
private ChangesRequiringRestart getChangesRequiringRestart(ProxyProtocol newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("proxyProtocol");
return changes;
}
}
/**
* This class represents connector.secureRedirect
*/
public final static class SecureRedirect extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Boolean enabled = null;
private Integer port = null;
public Builder() { }
public Builder(SecureRedirect config) {
enabled(config.enabled());
port(config.port());
}
private Builder override(Builder __superior) {
if (__superior.enabled != null)
enabled(__superior.enabled);
if (__superior.port != null)
port(__superior.port);
return this;
}
public Builder enabled(boolean __value) {
enabled = __value;
return this;
}
private Builder enabled(String __value) {
return enabled(Boolean.valueOf(__value));
}
public Builder port(int __value) {
port = __value;
return this;
}
private Builder port(String __value) {
return port(Integer.valueOf(__value));
}
public SecureRedirect build() {
return new SecureRedirect(this);
}
}
// Redirect all requests to https port
private final BooleanNode enabled;
// Target port for redirect
private final IntegerNode port;
public SecureRedirect(Builder builder) {
this(builder, true);
}
private SecureRedirect(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.secureRedirect must be initialized: " + builder.__uninitialized);
enabled = (builder.enabled == null) ?
new BooleanNode(false) : new BooleanNode(builder.enabled);
port = (builder.port == null) ?
new IntegerNode(443) : new IntegerNode(builder.port);
}
/**
* @return connector.secureRedirect.enabled
*/
public boolean enabled() {
return enabled.value();
}
/**
* @return connector.secureRedirect.port
*/
public int port() {
return port.value();
}
private ChangesRequiringRestart getChangesRequiringRestart(SecureRedirect newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("secureRedirect");
return changes;
}
}
/**
* This class represents connector.http2
*/
public final static class Http2 extends InnerNode {
public static class Builder implements ConfigBuilder {
private Set __uninitialized = new HashSet();
private Double streamIdleTimeout = null;
private Integer maxConcurrentStreams = null;
public Builder() { }
public Builder(Http2 config) {
streamIdleTimeout(config.streamIdleTimeout());
maxConcurrentStreams(config.maxConcurrentStreams());
}
private Builder override(Builder __superior) {
if (__superior.streamIdleTimeout != null)
streamIdleTimeout(__superior.streamIdleTimeout);
if (__superior.maxConcurrentStreams != null)
maxConcurrentStreams(__superior.maxConcurrentStreams);
return this;
}
public Builder streamIdleTimeout(double __value) {
streamIdleTimeout = __value;
return this;
}
private Builder streamIdleTimeout(String __value) {
return streamIdleTimeout(Double.valueOf(__value));
}
public Builder maxConcurrentStreams(int __value) {
maxConcurrentStreams = __value;
return this;
}
private Builder maxConcurrentStreams(String __value) {
return maxConcurrentStreams(Integer.valueOf(__value));
}
public Http2 build() {
return new Http2(this);
}
}
private final DoubleNode streamIdleTimeout;
private final IntegerNode maxConcurrentStreams;
public Http2(Builder builder) {
this(builder, true);
}
private Http2(Builder builder, boolean throwIfUninitialized) {
if (throwIfUninitialized && ! builder.__uninitialized.isEmpty())
throw new IllegalArgumentException("The following builder parameters for " +
"connector.http2 must be initialized: " + builder.__uninitialized);
streamIdleTimeout = (builder.streamIdleTimeout == null) ?
new DoubleNode(600D) : new DoubleNode(builder.streamIdleTimeout);
maxConcurrentStreams = (builder.maxConcurrentStreams == null) ?
new IntegerNode(4096) : new IntegerNode(builder.maxConcurrentStreams);
}
/**
* @return connector.http2.streamIdleTimeout
*/
public double streamIdleTimeout() {
return streamIdleTimeout.value();
}
/**
* @return connector.http2.maxConcurrentStreams
*/
public int maxConcurrentStreams() {
return maxConcurrentStreams.value();
}
private ChangesRequiringRestart getChangesRequiringRestart(Http2 newConfig) {
ChangesRequiringRestart changes = new ChangesRequiringRestart("http2");
return changes;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy