org.zalando.boot.cassandra.CassandraClusterFactoryBean Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of spring-boot-cassandra Show documentation
There is a newer version: 2.2
Show newest version
package org.zalando.boot.cassandra;

import org.springframework.beans.factory.config.AbstractFactoryBean;
import org.springframework.util.StringUtils;

import com.datastax.driver.core.AuthProvider;
import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.NettyOptions;
import com.datastax.driver.core.PoolingOptions;
import com.datastax.driver.core.ProtocolOptions;
import com.datastax.driver.core.ProtocolVersion;
import com.datastax.driver.core.QueryOptions;
import com.datastax.driver.core.SSLOptions;
import com.datastax.driver.core.SocketOptions;
import com.datastax.driver.core.TimestampGenerator;
import com.datastax.driver.core.policies.AddressTranslator;
import com.datastax.driver.core.policies.LoadBalancingPolicy;
import com.datastax.driver.core.policies.ReconnectionPolicy;
import com.datastax.driver.core.policies.RetryPolicy;
import com.datastax.driver.core.policies.SpeculativeExecutionPolicy;

import lombok.Getter;
import lombok.Setter;

/**
 * A factory bean that creates a single cassandra cluster client.
 */
@Getter
@Setter
public class CassandraClusterFactoryBean extends AbstractFactoryBean {

    /**
     * cluster name
     */
    private String clusterName;

    /**
     * contact points (defaults to localhost)
     */
    private String contactPoints = "localhost";

    /**
     * port (defaults to 9042
     */
    private int port = 9042;

    /**
     * protocol version
     */
    private ProtocolVersion protocolVersion;

    /**
     * compression
     */
    private ProtocolOptions.Compression compression;

    /**
     * load balancing policy
     */
    private LoadBalancingPolicy loadBalancingPolicy;

    /**
     * reconnection policy
     */
    private ReconnectionPolicy reconnectionPolicy;

    /**
     * speculative execution policy
     */
    private SpeculativeExecutionPolicy speculativeExecutionPolicy;

    /**
     * retry policy
     */
    private RetryPolicy retryPolicy;

    /**
     * address translator
     */
    private AddressTranslator addressTranslator;

    /**
     * query options
     */
    private QueryOptions queryOptions;
    
    /**
     * pooling options
     */
    private PoolingOptions poolingOptions;

    /**
     * socket options
     */
    private SocketOptions socketOptions;
    
    /**
     * netty options
     */
    private NettyOptions nettyOptions;
    
    /**
     * timestamp generator
     */
    private TimestampGenerator timestampGenerator;

    /**
     * auth provider
     */
    private AuthProvider authProvider;

    /**
     * username
     */
    private String username;

    /**
     * password
     */
    private String password;

    /**
     * indicates whether metrics gathering is enabled (defaults to true)
     */
    private boolean metricsEnabled = true;

    /**
     * indicates whether JMX reporting is enabled (defaults to true)
     */
    private boolean jmxEnabled = true;
    
    /**
     * indicates whether SSL is enabled (defaults to false)
     */
    private boolean sslEnabled = false;
    
    /**
     * SSL options
     */
    private SSLOptions sslOptions;

    /**
     * Creates a new CassandraClusterFactoryBean.
     */
    public CassandraClusterFactoryBean() {
        super();
    }

    /**
     * {@inheritDoc}
     * 
     * @see AbstractFactoryBean#createInstance()
     */
    @Override
    protected Cluster createInstance() throws Exception {
        Cluster.Builder clusterBuilder = Cluster.builder();

        if (clusterName != null) {
            clusterBuilder.withClusterName(clusterName);
        }

        // contact points and port
        if (!StringUtils.hasText(contactPoints)) {
            throw new IllegalArgumentException("contactPoints need to be set");
        }
        clusterBuilder.addContactPoints(StringUtils.commaDelimitedListToStringArray(contactPoints)).withPort(port);

        // protocol version
        if (protocolVersion != null) {
            clusterBuilder.withProtocolVersion(protocolVersion);
        }

        // protocol options
        if (compression != null) {
            clusterBuilder.withCompression(compression);
        }

        if (timestampGenerator != null) {
            clusterBuilder.withTimestampGenerator(timestampGenerator);
        }

        // policies
        if (loadBalancingPolicy != null) {
            clusterBuilder.withLoadBalancingPolicy(loadBalancingPolicy);
        }
        if (reconnectionPolicy != null) {
            clusterBuilder.withReconnectionPolicy(reconnectionPolicy);
        }
        if (retryPolicy != null) {
            clusterBuilder.withRetryPolicy(retryPolicy);
        }
        if (speculativeExecutionPolicy != null) {
            clusterBuilder.withSpeculativeExecutionPolicy(speculativeExecutionPolicy);
        }
        if (addressTranslator != null) {
            clusterBuilder.withAddressTranslator(addressTranslator);
        }

        // options
        if (queryOptions != null) {
            clusterBuilder.withQueryOptions(queryOptions);
        }
        if (poolingOptions != null) {
            clusterBuilder.withPoolingOptions(poolingOptions);
        }
        if (nettyOptions != null) {
            clusterBuilder.withNettyOptions(nettyOptions);
        }
        if (socketOptions != null) {
            clusterBuilder.withSocketOptions(socketOptions);
        }

        // authentication & authorization
        if (authProvider != null) {
            clusterBuilder.withAuthProvider(authProvider);
        } else if (username != null) {
            clusterBuilder.withCredentials(username, password);
        }

        // transport security
        if (sslEnabled) {
            if (sslOptions == null) {
                clusterBuilder.withSSL();
            } else {
                clusterBuilder.withSSL(sslOptions);
            }
        }
        
        // enablements
        if (!metricsEnabled) {
            clusterBuilder.withoutMetrics();
        }
        if (!jmxEnabled) {
            clusterBuilder.withoutJMXReporting();
        }

        return clusterBuilder.build();

    }

    /**
     * {@inheritDoc}
     * 
     * @see AbstractFactoryBean#destroyInstance(Object)
     */
    @Override
    protected void destroyInstance(Cluster instance) throws Exception {
        instance.close();
    }

    /**
     * {@inheritDoc}
     * 
     * @see AbstractFactoryBean#getObjectType()
     */
    @Override
    public Class getObjectType() {
        return Cluster.class;
    }
}