/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.tinkerpop.gremlin.driver;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.ChannelOption;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslProvider;
import io.netty.handler.ssl.util.InsecureTrustManagerFactory;
import org.apache.commons.configuration.Configuration;
import org.apache.tinkerpop.gremlin.driver.ser.Serializers;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.net.ssl.TrustManager;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.lang.ref.WeakReference;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
/**
* A connection to a set of one or more Gremlin Server instances.
*
* @author Stephen Mallette (http://stephen.genoprime.com)
*/
public final class Cluster {
private static final Logger logger = LoggerFactory.getLogger(Cluster.class);
private Manager manager;
private Cluster(final Builder builder) {
this.manager = new Manager(builder);
}
public synchronized void init() {
if (!manager.initialized)
manager.init();
}
/**
* Creates a {@link Client.ClusteredClient} instance to this {@code Cluster}, meaning requests will be routed to
* one or more servers (depending on the cluster configuration), where each request represents the entirety of a
* transaction. A commit or rollback (in case of error) is automatically executed at the end of the request.
* <p/>
* Note that calling this method does not imply that a connection is made to the server itself at this point.
* Therefore, if there is only one server specified in the {@code Cluster} and that server is not available an
* error will not be raised at this point. Connections get initialized in the {@link Client} when a request is
* submitted or can be directly initialized via {@link Client#init()}.
*/
public <T extends Client> T connect() {
final Client client = new Client.ClusteredClient(this, Client.Settings.build().create());
manager.trackClient(client);
return (T) client;
}
/**
* Creates a {@link Client.SessionedClient} instance to this {@code Cluster}, meaning requests will be routed to
* a single server (randomly selected from the cluster), where the same bindings will be available on each request.
* Requests are bound to the same thread on the server and thus transactions may extend beyond the bounds of a
* single request. The transactions are managed by the user and must be committed or rolled-back manually.
* <p/>
* Note that calling this method does not imply that a connection is made to the server itself at this point.
* Therefore, if there is only one server specified in the {@code Cluster} and that server is not available an
* error will not be raised at this point. Connections get initialized in the {@link Client} when a request is
* submitted or can be directly initialized via {@link Client#init()}.
*
* @param sessionId user supplied id for the session which should be unique (a UUID is ideal).
*/
public <T extends Client> T connect(final String sessionId) {
return connect(sessionId, false);
}
/**
* Creates a {@link Client.SessionedClient} instance to this {@code Cluster}, meaning requests will be routed to
* a single server (randomly selected from the cluster), where the same bindings will be available on each request.
* Requests are bound to the same thread on the server and thus transactions may extend beyond the bounds of a
* single request. If {@code manageTransactions} is set to {@code false} then transactions are managed by the
* user and must be committed or rolled-back manually. When set to {@code true} the transaction is committed or
* rolled-back at the end of each request.
* <p/>
* Note that calling this method does not imply that a connection is made to the server itself at this point.
* Therefore, if there is only one server specified in the {@code Cluster} and that server is not available an
* error will not be raised at this point. Connections get initialized in the {@link Client} when a request is
* submitted or can be directly initialized via {@link Client#init()}.
*
* @param sessionId user supplied id for the session which should be unique (a UUID is ideal).
* @param manageTransactions enables auto-transactions when set to true
*/
public <T extends Client> T connect(final String sessionId, final boolean manageTransactions) {
final Client.SessionSettings sessionSettings = Client.SessionSettings.build()
.manageTransactions(manageTransactions)
.sessionId(sessionId).create();
final Client.Settings settings = Client.Settings.build().useSession(sessionSettings).create();
return connect(settings);
}
/**
* Creates a new {@link Client} based on the settings provided.
*/
public <T extends Client> T connect(final Client.Settings settings) {
final Client client = settings.getSession().isPresent() ? new Client.SessionedClient(this, settings) :
new Client.ClusteredClient(this, settings);
manager.trackClient(client);
return (T) client;
}
@Override
public String toString() {
return manager.toString();
}
public static Builder build() {
return new Builder();
}
public static Builder build(final String address) {
return new Builder(address);
}
public static Builder build(final File configurationFile) throws FileNotFoundException {
final Settings settings = Settings.read(new FileInputStream(configurationFile));
return getBuilderFromSettings(settings);
}
private static Builder getBuilderFromSettings(final Settings settings) {
final List<String> addresses = settings.hosts;
if (addresses.size() == 0)
throw new IllegalStateException("At least one value must be specified to the hosts setting");
final Builder builder = new Builder(settings.hosts.get(0))
.port(settings.port)
.enableSsl(settings.connectionPool.enableSsl)
.trustCertificateChainFile(settings.connectionPool.trustCertChainFile)
.keepAliveInterval(settings.connectionPool.keepAliveInterval)
.keyCertChainFile(settings.connectionPool.keyCertChainFile)
.keyFile(settings.connectionPool.keyFile)
.keyPassword(settings.connectionPool.keyPassword)
.nioPoolSize(settings.nioPoolSize)
.workerPoolSize(settings.workerPoolSize)
.reconnectInterval(settings.connectionPool.reconnectInterval)
.reconnectIntialDelay(settings.connectionPool.reconnectInitialDelay)
.resultIterationBatchSize(settings.connectionPool.resultIterationBatchSize)
.channelizer(settings.connectionPool.channelizer)
.maxContentLength(settings.connectionPool.maxContentLength)
.maxWaitForConnection(settings.connectionPool.maxWaitForConnection)
.maxInProcessPerConnection(settings.connectionPool.maxInProcessPerConnection)
.minInProcessPerConnection(settings.connectionPool.minInProcessPerConnection)
.maxSimultaneousUsagePerConnection(settings.connectionPool.maxSimultaneousUsagePerConnection)
.minSimultaneousUsagePerConnection(settings.connectionPool.minSimultaneousUsagePerConnection)
.maxConnectionPoolSize(settings.connectionPool.maxSize)
.minConnectionPoolSize(settings.connectionPool.minSize);
if (settings.username != null && settings.password != null)
builder.credentials(settings.username, settings.password);
if (settings.jaasEntry != null)
builder.jaasEntry(settings.jaasEntry);
if (settings.protocol != null)
builder.protocol(settings.protocol);
// the first address was added above in the constructor, so skip it if there are more
if (addresses.size() > 1)
addresses.stream().skip(1).forEach(builder::addContactPoint);
try {
builder.serializer(settings.serializer.create());
} catch (Exception ex) {
throw new IllegalStateException("Could not establish serializer - " + ex.getMessage());
}
return builder;
}
/**
* Create a {@code Cluster} with all default settings which will connect to one contact point at {@code localhost}.
*/
public static Cluster open() {
return build("localhost").create();
}
/**
* Create a {@code Cluster} from Apache Configurations.
*/
public static Cluster open(final Configuration conf) {
return getBuilderFromSettings(Settings.from(conf)).create();
}
/**
* Create a {@code Cluster} using a YAML-based configuration file.
*/
public static Cluster open(final String configurationFile) throws Exception {
final File file = new File(configurationFile);
if (!file.exists())
throw new IllegalArgumentException(String.format("Configuration file at %s does not exist", configurationFile));
return build(file).create();
}
public void close() {
closeAsync().join();
}
public CompletableFuture<Void> closeAsync() {
return manager.close();
}
/**
* Determines if the {@code Cluster} is in the process of closing given a call to {@link #close} or
* {@link #closeAsync()}.
*/
public boolean isClosing() {
return manager.isClosing();
}
/**
* Determines if the {@code Cluster} has completed its closing process after a call to {@link #close} or
* {@link #closeAsync()}.
*/
public boolean isClosed() {
return manager.isClosing() && manager.close().isDone();
}
/**
* Gets the list of hosts that the {@code Cluster} was able to connect to. A {@link Host} is assumed unavailable
* until a connection to it is proven to be present. This will not happen until the {@link Client} submits
* requests that succeed in reaching a server at the {@link Host} or {@link Client#init()} is called which
* initializes the {@link ConnectionPool} for the {@link Client} itself. The number of available hosts returned
* from this method will change as different servers come on and offline.
*/
public List<URI> availableHosts() {
return Collections.unmodifiableList(allHosts().stream()
.filter(Host::isAvailable)
.map(Host::getHostUri)
.collect(Collectors.toList()));
}
/**
* Size of the pool for handling request/response operations.
*/
public int getNioPoolSize() {
return manager.nioPoolSize;
}
/**
* Size of the pool for handling background work.
*/
public int getWorkerPoolSize() {
return manager.workerPoolSize;
}
/**
* Get the {@link MessageSerializer} MIME types supported.
*/
public String[] getSerializers() {
return getSerializer().mimeTypesSupported();
}
/**
* Determines if connectivity over SSL is enabled.
*/
public boolean isSslEnabled() {
return manager.connectionPoolSettings.enableSsl;
}
/**
* Gets the minimum number of in-flight requests that can occur on a {@link Connection} before it is considered
* for closing on return to the {@link ConnectionPool}.
*/
public int getMinInProcessPerConnection() {
return manager.connectionPoolSettings.minInProcessPerConnection;
}
/**
* Gets the maximum number of in-flight requests that can occur on a {@link Connection}.
*/
public int getMaxInProcessPerConnection() {
return manager.connectionPoolSettings.maxInProcessPerConnection;
}
/**
* Gets the maximum number of times that a {@link Connection} can be borrowed from the pool simultaneously.
*/
public int maxSimultaneousUsagePerConnection() {
return manager.connectionPoolSettings.maxSimultaneousUsagePerConnection;
}
/**
* Gets the minimum number of times that a {@link Connection} should be borrowed from the pool before it falls
* under consideration for closing.
*/
public int minSimultaneousUsagePerConnection() {
return manager.connectionPoolSettings.minSimultaneousUsagePerConnection;
}
/**
* Gets the maximum size that the {@link ConnectionPool} can grow.
*/
public int maxConnectionPoolSize() {
return manager.connectionPoolSettings.maxSize;
}
/**
* Gets the minimum size of the {@link ConnectionPool}.
*/
public int minConnectionPoolSize() {
return manager.connectionPoolSettings.minSize;
}
/**
* Gets the override for the server setting that determines how many results are returned per batch.
*/
public int getResultIterationBatchSize() {
return manager.connectionPoolSettings.resultIterationBatchSize;
}
/**
* Gets the maximum amount of time to wait for a connection to be borrowed from the connection pool.
*/
public int getMaxWaitForConnection() {
return manager.connectionPoolSettings.maxWaitForConnection;
}
/**
* Gets how long a session will stay open assuming the current connection actually is configured for their use.
*/
public int getMaxWaitForSessionClose() {
return manager.connectionPoolSettings.maxWaitForSessionClose;
}
/**
* Gets the maximum size in bytes of any request sent to the server.
*/
public int getMaxContentLength() {
return manager.connectionPoolSettings.maxContentLength;
}
/**
* Gets the {@link Channelizer} implementation to use on the client when creating a {@link Connection}.
*/
public String getChannelizer() {
return manager.connectionPoolSettings.channelizer;
}
/**
* Gets time in milliseconds to wait before attempting to reconnect to a dead host after it has been marked dead.
*/
public int getReconnectIntialDelay() {
return manager.connectionPoolSettings.reconnectInitialDelay;
}
/**
* Gets time in milliseconds to wait between retries when attempting to reconnect to a dead host.
*/
public int getReconnectInterval() {
return manager.connectionPoolSettings.reconnectInterval;
}
/**
* Gets time in milliseconds to wait after the last message is sent over a connection before sending a keep-alive
* message to the server.
*/
public long getKeepAliveInterval() {
return manager.connectionPoolSettings.keepAliveInterval;
}
/**
* Specifies the load balancing strategy to use on the client side.
*/
public Class<? extends LoadBalancingStrategy> getLoadBalancingStrategy() {
return manager.loadBalancingStrategy.getClass();
}
/**
* Gets the port that the Gremlin Servers will be listening on.
*/
public int getPort() {
return manager.port;
}
/**
* Gets a list of all the configured hosts.
*/
public Collection<Host> allHosts() {
return Collections.unmodifiableCollection(manager.allHosts());
}
Factory getFactory() {
return manager.factory;
}
MessageSerializer getSerializer() {
return manager.serializer;
}
ScheduledExecutorService executor() {
return manager.executor;
}
Settings.ConnectionPoolSettings connectionPoolSettings() {
return manager.connectionPoolSettings;
}
LoadBalancingStrategy loadBalancingStrategy() {
return manager.loadBalancingStrategy;
}
AuthProperties authProperties() {
return manager.authProps;
}
SslContext createSSLContext() throws Exception {
// if the context is provided then just use that and ignore the other settings
if (manager.sslContextOptional.isPresent()) return manager.sslContextOptional.get();
final SslProvider provider = SslProvider.JDK;
final Settings.ConnectionPoolSettings connectionPoolSettings = connectionPoolSettings();
final SslContextBuilder builder = SslContextBuilder.forClient();
if (connectionPoolSettings.trustCertChainFile != null)
builder.trustManager(new File(connectionPoolSettings.trustCertChainFile));
else {
logger.warn("SSL configured without a trustCertChainFile and thus trusts all certificates without verification (not suitable for production)");
builder.trustManager(InsecureTrustManagerFactory.INSTANCE);
}
if (null != connectionPoolSettings.keyCertChainFile && null != connectionPoolSettings.keyFile) {
final File keyCertChainFile = new File(connectionPoolSettings.keyCertChainFile);
final File keyFile = new File(connectionPoolSettings.keyFile);
// note that keyPassword may be null here if the keyFile is not password-protected.
builder.keyManager(keyCertChainFile, keyFile, connectionPoolSettings.keyPassword);
}
builder.sslProvider(provider);
return builder.build();
}
public final static class Builder {
private List<InetAddress> addresses = new ArrayList<>();
private int port = 8182;
private MessageSerializer serializer = Serializers.GRYO_V1D0.simpleInstance();
private int nioPoolSize = Runtime.getRuntime().availableProcessors();
private int workerPoolSize = Runtime.getRuntime().availableProcessors() * 2;
private int minConnectionPoolSize = ConnectionPool.MIN_POOL_SIZE;
private int maxConnectionPoolSize = ConnectionPool.MAX_POOL_SIZE;
private int minSimultaneousUsagePerConnection = ConnectionPool.MIN_SIMULTANEOUS_USAGE_PER_CONNECTION;
private int maxSimultaneousUsagePerConnection = ConnectionPool.MAX_SIMULTANEOUS_USAGE_PER_CONNECTION;
private int maxInProcessPerConnection = Connection.MAX_IN_PROCESS;
private int minInProcessPerConnection = Connection.MIN_IN_PROCESS;
private int maxWaitForConnection = Connection.MAX_WAIT_FOR_CONNECTION;
private int maxWaitForSessionClose = Connection.MAX_WAIT_FOR_SESSION_CLOSE;
private int maxContentLength = Connection.MAX_CONTENT_LENGTH;
private int reconnectInitialDelay = Connection.RECONNECT_INITIAL_DELAY;
private int reconnectInterval = Connection.RECONNECT_INTERVAL;
private int resultIterationBatchSize = Connection.RESULT_ITERATION_BATCH_SIZE;
private long keepAliveInterval = Connection.KEEP_ALIVE_INTERVAL;
private String channelizer = Channelizer.WebSocketChannelizer.class.getName();
private boolean enableSsl = false;
private String trustCertChainFile = null;
private String keyCertChainFile = null;
private String keyFile = null;
private String keyPassword = null;
private SslContext sslContext = null;
private LoadBalancingStrategy loadBalancingStrategy = new LoadBalancingStrategy.RoundRobin();
private AuthProperties authProps = new AuthProperties();
private Builder() {
// empty to prevent direct instantiation
}
private Builder(final String address) {
addContactPoint(address);
}
/**
* Size of the pool for handling request/response operations. Defaults to the number of available processors.
*/
public Builder nioPoolSize(final int nioPoolSize) {
this.nioPoolSize = nioPoolSize;
return this;
}
/**
* Size of the pool for handling background work. Defaults to the number of available processors multiplied
* by 2
*/
public Builder workerPoolSize(final int workerPoolSize) {
this.workerPoolSize = workerPoolSize;
return this;
}
/**
* Set the {@link MessageSerializer} to use given its MIME type. Note that setting this value this way
* will not allow specific configuration of the serializer itself. If specific configuration is required
* please use {@link #serializer(MessageSerializer)}.
*/
public Builder serializer(final String mimeType) {
serializer = Serializers.valueOf(mimeType).simpleInstance();
return this;
}
/**
* Set the {@link MessageSerializer} to use via the {@link Serializers} enum. If specific configuration is
* required please use {@link #serializer(MessageSerializer)}.
*/
public Builder serializer(final Serializers mimeType) {
serializer = mimeType.simpleInstance();
return this;
}
/**
* Sets the {@link MessageSerializer} to use.
*/
public Builder serializer(final MessageSerializer serializer) {
this.serializer = serializer;
return this;
}
/**
* Enables connectivity over SSL - note that the server should be configured with SSL turned on for this
* setting to work properly.
*/
public Builder enableSsl(final boolean enable) {
this.enableSsl = enable;
return this;
}
/**
* Explicitly set the {@code SslContext} for when more flexibility is required in the configuration than is
* allowed by the {@link Builder}. If this value is set to something other than {@code null} then all other
* related SSL settings are ignored. The {@link #enableSsl} setting should still be set to {@code true} for
* this setting to take effect.
*/
public Builder sslContext(final SslContext sslContext) {
this.sslContext = sslContext;
return this;
}
/**
* File location for a SSL Certificate Chain to use when SSL is enabled. If this value is not provided and
* SSL is enabled, the {@link TrustManager} will be established with a self-signed certificate which is NOT
* suitable for production purposes.
*/
public Builder trustCertificateChainFile(final String certificateChainFile) {
this.trustCertChainFile = certificateChainFile;
return this;
}
/**
* Length of time in milliseconds to wait on an idle connection before sending a keep-alive request. This
* setting is only relevant to {@link Channelizer} implementations that return {@code true} for
* {@link Channelizer#supportsKeepAlive()}. Set to zero to disable this feature.
*/
public Builder keepAliveInterval(final long keepAliveInterval) {
this.keepAliveInterval = keepAliveInterval;
return this;
}
/**
* The X.509 certificate chain file in PEM format.
*/
public Builder keyCertChainFile(final String keyCertChainFile) {
this.keyCertChainFile = keyCertChainFile;
return this;
}
/**
* The PKCS#8 private key file in PEM format.
*/
public Builder keyFile(final String keyFile) {
this.keyFile = keyFile;
return this;
}
/**
* The password of the {@link #keyFile}, or {@code null} if it's not password-protected.
*/
public Builder keyPassword(final String keyPassword) {
this.keyPassword = keyPassword;
return this;
}
/**
* The minimum number of in-flight requests that can occur on a {@link Connection} before it is considered
* for closing on return to the {@link ConnectionPool}.
*/
public Builder minInProcessPerConnection(final int minInProcessPerConnection) {
this.minInProcessPerConnection = minInProcessPerConnection;
return this;
}
/**
* The maximum number of in-flight requests that can occur on a {@link Connection}. This represents an
* indication of how busy a {@link Connection} is allowed to be. This number is linked to the
* {@link #maxSimultaneousUsagePerConnection} setting, but is slightly different in that it refers to
* the total number of requests on a {@link Connection}. In other words, a {@link Connection} might
* be borrowed once to have multiple requests executed against it. This number controls the maximum
* number of requests whereas {@link #maxInProcessPerConnection} controls the times borrowed.
*/
public Builder maxInProcessPerConnection(final int maxInProcessPerConnection) {
this.maxInProcessPerConnection = maxInProcessPerConnection;
return this;
}
/**
* The maximum number of times that a {@link Connection} can be borrowed from the pool simultaneously.
* This represents an indication of how busy a {@link Connection} is allowed to be. Set too large and the
* {@link Connection} may queue requests too quickly, rather than wait for an available {@link Connection}
* or create a fresh one. If set too small, the {@link Connection} will show as busy very quickly thus
* forcing waits for available {@link Connection} instances in the pool when there is more capacity available.
*/
public Builder maxSimultaneousUsagePerConnection(final int maxSimultaneousUsagePerConnection) {
this.maxSimultaneousUsagePerConnection = maxSimultaneousUsagePerConnection;
return this;
}
/**
* The minimum number of times that a {@link Connection} should be borrowed from the pool before it falls
* under consideration for closing. If a {@link Connection} is not busy and the
* {@link #minConnectionPoolSize} is exceeded, then there is no reason to keep that connection open. Set
* too large and {@link Connection} that isn't busy will continue to consume resources when it is not being
* used. Set too small and {@link Connection} instances will be destroyed when the driver might still be
* busy.
*/
public Builder minSimultaneousUsagePerConnection(final int minSimultaneousUsagePerConnection) {
this.minSimultaneousUsagePerConnection = minSimultaneousUsagePerConnection;
return this;
}
/**
* The maximum size that the {@link ConnectionPool} can grow.
*/
public Builder maxConnectionPoolSize(final int maxSize) {
this.maxConnectionPoolSize = maxSize;
return this;
}
/**
* The minimum size of the {@link ConnectionPool}. When the {@link Client} is started, {@link Connection}
* objects will be initially constructed to this size.
*/
public Builder minConnectionPoolSize(final int minSize) {
this.minConnectionPoolSize = minSize;
return this;
}
/**
* Override the server setting that determines how many results are returned per batch.
*/
public Builder resultIterationBatchSize(final int size) {
this.resultIterationBatchSize = size;
return this;
}
/**
* The maximum amount of time to wait for a connection to be borrowed from the connection pool.
*/
public Builder maxWaitForConnection(final int maxWait) {
this.maxWaitForConnection = maxWait;
return this;
}
/**
* If the connection is using a "session" this setting represents the amount of time in milliseconds to wait
* for that session to close before timing out where the default value is 3000. Note that the server will
* eventually clean up dead sessions itself on expiration of the session or during shutdown.
*/
public Builder maxWaitForSessionClose(final int maxWait) {
this.maxWaitForSessionClose = maxWait;
return this;
}
/**
* The maximum size in bytes of any request sent to the server. This number should not exceed the same
* setting defined on the server.
*/
public Builder maxContentLength(final int maxContentLength) {
this.maxContentLength = maxContentLength;
return this;
}
/**
* Specify the {@link Channelizer} implementation to use on the client when creating a {@link Connection}.
*/
public Builder channelizer(final String channelizerClass) {
this.channelizer = channelizerClass;
return this;
}
/**
* Specify the {@link Channelizer} implementation to use on the client when creating a {@link Connection}.
*/
public Builder channelizer(final Class channelizerClass) {
return channelizer(channelizerClass.getCanonicalName());
}
/**
* Time in milliseconds to wait before attempting to reconnect to a dead host after it has been marked dead.
*
* @deprecated As of release 3.2.3, the value of the initial delay is now the same as the {@link #reconnectInterval}.
*/
@Deprecated
public Builder reconnectIntialDelay(final int initialDelay) {
this.reconnectInitialDelay = initialDelay;
return this;
}
/**
* Time in milliseconds to wait between retries when attempting to reconnect to a dead host.
*/
public Builder reconnectInterval(final int interval) {
this.reconnectInterval = interval;
return this;
}
/**
* Specifies the load balancing strategy to use on the client side.
*/
public Builder loadBalancingStrategy(final LoadBalancingStrategy loadBalancingStrategy) {
this.loadBalancingStrategy = loadBalancingStrategy;
return this;
}
/**
* Specifies parameters for authentication to Gremlin Server.
*/
public Builder authProperties(final AuthProperties authProps) {
this.authProps = authProps;
return this;
}
/**
* Sets the {@link AuthProperties.Property#USERNAME} and {@link AuthProperties.Property#PASSWORD} properties
* for authentication to Gremlin Server.
*/
public Builder credentials(final String username, final String password) {
authProps = authProps.with(AuthProperties.Property.USERNAME, username).with(AuthProperties.Property.PASSWORD, password);
return this;
}
/**
* Sets the {@link AuthProperties.Property#PROTOCOL} properties for authentication to Gremlin Server.
*/
public Builder protocol(final String protocol) {
this.authProps = authProps.with(AuthProperties.Property.PROTOCOL, protocol);
return this;
}
/**
* Sets the {@link AuthProperties.Property#JAAS_ENTRY} properties for authentication to Gremlin Server.
*/
public Builder jaasEntry(final String jaasEntry) {
this.authProps = authProps.with(AuthProperties.Property.JAAS_ENTRY, jaasEntry);
return this;
}
/**
* Adds the address of a Gremlin Server to the list of servers a {@link Client} will try to contact to send
* requests to. The address should be parseable by {@link InetAddress#getByName(String)}. That's the only
* validation performed at this point. No connection to the host is attempted.
*/
public Builder addContactPoint(final String address) {
try {
this.addresses.add(InetAddress.getByName(address));
return this;
} catch (UnknownHostException e) {
throw new IllegalArgumentException(e.getMessage());
}
}
/**
* Add one or more the addresses of a Gremlin Servers to the list of servers a {@link Client} will try to
* contact to send requests to. The address should be parseable by {@link InetAddress#getByName(String)}.
* That's the only validation performed at this point. No connection to the host is attempted.
*/
public Builder addContactPoints(final String... addresses) {
for (String address : addresses)
addContactPoint(address);
return this;
}
/**
* Sets the port that the Gremlin Servers will be listening on.
*/
public Builder port(final int port) {
this.port = port;
return this;
}
List<InetSocketAddress> getContactPoints() {
return addresses.stream().map(addy -> new InetSocketAddress(addy, port)).collect(Collectors.toList());
}
public Cluster create() {
if (addresses.size() == 0) addContactPoint("localhost");
return new Cluster(this);
}
}
static class Factory {
private final EventLoopGroup group;
public Factory(final int nioPoolSize) {
final BasicThreadFactory threadFactory = new BasicThreadFactory.Builder().namingPattern("gremlin-driver-loop-%d").build();
group = new NioEventLoopGroup(nioPoolSize, threadFactory);
}
Bootstrap createBootstrap() {
final Bootstrap b = new Bootstrap().group(group);
b.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
return b;
}
void shutdown() {
group.shutdownGracefully().awaitUninterruptibly();
}
}
class Manager {
private final ConcurrentMap<InetSocketAddress, Host> hosts = new ConcurrentHashMap<>();
private boolean initialized;
private final List<InetSocketAddress> contactPoints;
private final Factory factory;
private final MessageSerializer serializer;
private final Settings.ConnectionPoolSettings connectionPoolSettings;
private final LoadBalancingStrategy loadBalancingStrategy;
private final AuthProperties authProps;
private final Optional<SslContext> sslContextOptional;
private final ScheduledExecutorService executor;
private final int nioPoolSize;
private final int workerPoolSize;
private final int port;
private final AtomicReference<CompletableFuture<Void>> closeFuture = new AtomicReference<>();
private final List<WeakReference<Client>> openedClients = new ArrayList<>();
private Manager(final Builder builder) {
validateBuilder(builder);
this.loadBalancingStrategy = builder.loadBalancingStrategy;
this.authProps = builder.authProps;
this.contactPoints = builder.getContactPoints();
connectionPoolSettings = new Settings.ConnectionPoolSettings();
connectionPoolSettings.maxInProcessPerConnection = builder.maxInProcessPerConnection;
connectionPoolSettings.minInProcessPerConnection = builder.minInProcessPerConnection;
connectionPoolSettings.maxSimultaneousUsagePerConnection = builder.maxSimultaneousUsagePerConnection;
connectionPoolSettings.minSimultaneousUsagePerConnection = builder.minSimultaneousUsagePerConnection;
connectionPoolSettings.maxSize = builder.maxConnectionPoolSize;
connectionPoolSettings.minSize = builder.minConnectionPoolSize;
connectionPoolSettings.maxWaitForConnection = builder.maxWaitForConnection;
connectionPoolSettings.maxWaitForSessionClose = builder.maxWaitForSessionClose;
connectionPoolSettings.maxContentLength = builder.maxContentLength;
connectionPoolSettings.reconnectInitialDelay = builder.reconnectInitialDelay;
connectionPoolSettings.reconnectInterval = builder.reconnectInterval;
connectionPoolSettings.resultIterationBatchSize = builder.resultIterationBatchSize;
connectionPoolSettings.enableSsl = builder.enableSsl;
connectionPoolSettings.trustCertChainFile = builder.trustCertChainFile;
connectionPoolSettings.keyCertChainFile = builder.keyCertChainFile;
connectionPoolSettings.keyFile = builder.keyFile;
connectionPoolSettings.keyPassword = builder.keyPassword;
connectionPoolSettings.keepAliveInterval = builder.keepAliveInterval;
connectionPoolSettings.channelizer = builder.channelizer;
sslContextOptional = Optional.ofNullable(builder.sslContext);
nioPoolSize = builder.nioPoolSize;
workerPoolSize = builder.workerPoolSize;
port = builder.port;
this.factory = new Factory(builder.nioPoolSize);
this.serializer = builder.serializer;
this.executor = Executors.newScheduledThreadPool(builder.workerPoolSize,
new BasicThreadFactory.Builder().namingPattern("gremlin-driver-worker-%d").build());
}
private void validateBuilder(final Builder builder) {
if (builder.minInProcessPerConnection < 0)
throw new IllegalArgumentException("minInProcessPerConnection must be greater than or equal to zero");
if (builder.maxInProcessPerConnection < 1)
throw new IllegalArgumentException("maxInProcessPerConnection must be greater than zero");
if (builder.minInProcessPerConnection > builder.maxInProcessPerConnection)
throw new IllegalArgumentException("maxInProcessPerConnection cannot be less than minInProcessPerConnection");
if (builder.minSimultaneousUsagePerConnection < 0)
throw new IllegalArgumentException("minSimultaneousUsagePerConnection must be greater than or equal to zero");
if (builder.maxSimultaneousUsagePerConnection < 1)
throw new IllegalArgumentException("maxSimultaneousUsagePerConnection must be greater than zero");
if (builder.minSimultaneousUsagePerConnection > builder.maxSimultaneousUsagePerConnection)
throw new IllegalArgumentException("maxSimultaneousUsagePerConnection cannot be less than minSimultaneousUsagePerConnection");
if (builder.minConnectionPoolSize < 0)
throw new IllegalArgumentException("minConnectionPoolSize must be greater than or equal to zero");
if (builder.maxConnectionPoolSize < 1)
throw new IllegalArgumentException("maxConnectionPoolSize must be greater than zero");
if (builder.minConnectionPoolSize > builder.maxConnectionPoolSize)
throw new IllegalArgumentException("maxConnectionPoolSize cannot be less than minConnectionPoolSize");
if (builder.maxWaitForConnection < 1)
throw new IllegalArgumentException("maxWaitForConnection must be greater than zero");
if (builder.maxWaitForSessionClose < 1)
throw new IllegalArgumentException("maxWaitForSessionClose must be greater than zero");
if (builder.maxContentLength < 1)
throw new IllegalArgumentException("maxContentLength must be greater than zero");
if (builder.reconnectInterval < 1)
throw new IllegalArgumentException("reconnectInterval must be greater than zero");
if (builder.resultIterationBatchSize < 1)
throw new IllegalArgumentException("resultIterationBatchSize must be greater than zero");
if (builder.nioPoolSize < 1)
throw new IllegalArgumentException("nioPoolSize must be greater than zero");
if (builder.workerPoolSize < 1)
throw new IllegalArgumentException("workerPoolSize must be greater than zero");
}
synchronized void init() {
if (initialized)
return;
initialized = true;
contactPoints.forEach(address -> {
final Host host = add(address);
if (host != null)
host.makeAvailable();
});
}
void trackClient(final Client client) {
openedClients.add(new WeakReference<>(client));
}
public Host add(final InetSocketAddress address) {
final Host newHost = new Host(address, Cluster.this);
final Host previous = hosts.putIfAbsent(address, newHost);
return previous == null ? newHost : null;
}
Collection<Host> allHosts() {
return hosts.values();
}
synchronized CompletableFuture<Void> close() {
// this method is exposed publicly in both blocking and non-blocking forms.
if (closeFuture.get() != null)
return closeFuture.get();
for (WeakReference<Client> openedClient : openedClients) {
final Client client = openedClient.get();
if (client != null && !client.isClosing()) {
client.close();
}
}
final CompletableFuture<Void> closeIt = new CompletableFuture<>();
closeFuture.set(closeIt);
executor().submit(() -> {
factory.shutdown();
closeIt.complete(null);
});
// Prevent the executor from accepting new tasks while still allowing enqueued tasks to complete
executor.shutdown();
return closeIt;
}
boolean isClosing() {
return closeFuture.get() != null;
}
@Override
public String toString() {
return String.join(", ", contactPoints.stream().map(InetSocketAddress::toString).collect(Collectors.<String>toList()));
}
}
}