com.datastax.driver.core.AuthProvider Java Examples

private AuthProvider getAuthProvider() throws StageException {
  switch (conf.authProviderOption) {
    case NONE:
      return AuthProvider.NONE;
    case PLAINTEXT:
      return new PlainTextAuthProvider(conf.username.get(), conf.password.get());
    case DSE_PLAINTEXT:
      return new DsePlainTextAuthProvider(conf.username.get(), conf.password.get());
    case KERBEROS:
      AccessControlContext accessContext = AccessController.getContext();
      Subject subject = Subject.getSubject(accessContext);
      return DseGSSAPIAuthProvider.builder().withSubject(subject).build();
    default:
      throw new IllegalArgumentException("Unrecognized AuthProvider: " + conf.authProviderOption);
  }
}
 

private static AuthProvider getClientAuthProvider(String factoryClassName, Configuration conf)
{
    try
    {
        Class<?> c = Class.forName(factoryClassName);
        if (PlainTextAuthProvider.class.equals(c))
        {
            String username = getStringSetting(USERNAME, conf).or("");
            String password = getStringSetting(PASSWORD, conf).or("");
            return (AuthProvider) c.getConstructor(String.class, String.class)
                    .newInstance(username, password);
        }
        else
        {
            return (AuthProvider) c.newInstance();
        }
    }
    catch (Exception e)
    {
        throw new RuntimeException("Failed to instantiate auth provider:" + factoryClassName, e);
    }
}
 

@Override
protected AuthProvider getAuthProvider() {
	if (StringUtils.hasText(this.cassandraProperties.getUsername())) {
		return new PlainTextAuthProvider(this.cassandraProperties.getUsername(),
				this.cassandraProperties.getPassword());
	}
	else {
		return null;
	}
}
 

/** {@inheritDoc} */
@SuppressWarnings("unchecked")
@Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    fetchSize = (Integer)in.readObject();
    readConsistency = (ConsistencyLevel)in.readObject();
    writeConsistency = (ConsistencyLevel)in.readObject();
    user = U.readString(in);
    pwd = U.readString(in);
    port = (Integer)in.readObject();
    contactPoints = (List<InetAddress>)in.readObject();
    contactPointsWithPorts = (List<InetSocketAddress>)in.readObject();
    maxSchemaAgreementWaitSeconds = (Integer)in.readObject();
    protoVer = (Integer)in.readObject();
    compression = U.readString(in);
    useSSL = (Boolean)in.readObject();
    collectMetrix = (Boolean)in.readObject();
    jmxReporting = (Boolean)in.readObject();
    creds = (Credentials)in.readObject();
    loadBalancingPlc = (LoadBalancingPolicy)readObject(in);
    reconnectionPlc = (ReconnectionPolicy)readObject(in);
    addrTranslator = (AddressTranslator)readObject(in);
    speculativeExecutionPlc = (SpeculativeExecutionPolicy)readObject(in);
    authProvider = (AuthProvider)readObject(in);
    sslOptions = (SSLOptions)readObject(in);
    poolingOptions = (PoolingOptions)readObject(in);
    sockOptions = (SocketOptions)readObject(in);
    nettyOptions = (NettyOptions)readObject(in);
}
 

public static Cluster getInputCluster(String[] hosts, Configuration conf)
{
    int port = getInputNativePort(conf);
    Optional<AuthProvider> authProvider = getAuthProvider(conf);
    Optional<SSLOptions> sslOptions = getSSLOptions(conf);
    Optional<Integer> protocolVersion = getProtocolVersion(conf);
    LoadBalancingPolicy loadBalancingPolicy = getReadLoadBalancingPolicy(conf, hosts);
    SocketOptions socketOptions = getReadSocketOptions(conf);
    QueryOptions queryOptions = getReadQueryOptions(conf);
    PoolingOptions poolingOptions = getReadPoolingOptions(conf);
    
    Cluster.Builder builder = Cluster.builder()
                                     .addContactPoints(hosts)
                                     .withPort(port)
                                     .withCompression(ProtocolOptions.Compression.NONE);

    if (authProvider.isPresent())
        builder.withAuthProvider(authProvider.get());
    if (sslOptions.isPresent())
        builder.withSSL(sslOptions.get());

    if (protocolVersion.isPresent()) {
        builder.withProtocolVersion(protocolVersion.get());
    }
    builder.withLoadBalancingPolicy(loadBalancingPolicy)
           .withSocketOptions(socketOptions)
           .withQueryOptions(queryOptions)
           .withPoolingOptions(poolingOptions);

    return builder.build();
}
 

private static Optional<AuthProvider> getAuthProvider(Configuration conf)
{
    Optional<String> authProvider = getInputNativeAuthProvider(conf);
    if (!authProvider.isPresent())
        return Optional.absent();

    return Optional.of(getClientAuthProvider(authProvider.get(), conf));
}
 

@Override
protected AuthProvider getAuthProvider() {
	return new PlainTextAuthProvider(cassandraUsername, cassandraPassword);
}
 

@Override
protected AuthProvider getAuthProvider() {
    return new PlainTextAuthProvider(this.cassandraProperties.getUsername(),
            this.cassandraProperties.getPassword());
}
 

private com.datastax.driver.core.Cluster.Builder newCqlDriverBuilder(ConnectionPoolConfiguration poolConfig,
                                                                     MetricRegistry metricRegistry) {
    performHostDiscovery(metricRegistry);

    String[] seeds = _seeds.split(",");
    List<String> contactPoints = Lists.newArrayListWithCapacity(seeds.length);

    // Each seed may be a host name or a host name and port (e.g.; "1.2.3.4" or "1.2.3.4:9160").  These need
    // to be converted into host names only.
    for (String seed : seeds) {
        HostAndPort hostAndPort = HostAndPort.fromString(seed);
        seed = hostAndPort.getHostText();
        if (hostAndPort.hasPort()) {
            if (hostAndPort.getPort() == _thriftPort) {
                _log.debug("Seed {} found using RPC port; swapping for native port {}", seed, _cqlPort);
            } else if (hostAndPort.getPort() != _cqlPort) {
                throw new IllegalArgumentException(String.format(
                        "Seed %s found with invalid port %s.  The port must match either the RPC (thrift) port %s " +
                        "or the native (CQL) port %s", seed, hostAndPort.getPort(), _thriftPort, _cqlPort));
            }
        }

        contactPoints.add(seed);
    }

    PoolingOptions poolingOptions = new PoolingOptions();
    if (poolConfig.getMaxConnectionsPerHost().or(getMaxConnectionsPerHost()).isPresent()) {
        poolingOptions.setMaxConnectionsPerHost(HostDistance.LOCAL, poolConfig.getMaxConnectionsPerHost().or(getMaxConnectionsPerHost()).get());
    }
    if (poolConfig.getCoreConnectionsPerHost().or(getCoreConnectionsPerHost()).isPresent()) {
        poolingOptions.setCoreConnectionsPerHost(HostDistance.LOCAL, poolConfig.getCoreConnectionsPerHost().or(getCoreConnectionsPerHost()).get());
    }

    SocketOptions socketOptions = new SocketOptions();
    if (poolConfig.getConnectTimeout().or(getConnectTimeout()).isPresent()) {
        socketOptions.setConnectTimeoutMillis(poolConfig.getConnectTimeout().or(getConnectTimeout()).get());
    }
    if (poolConfig.getSocketTimeout().or(getSocketTimeout()).isPresent()) {
        socketOptions.setReadTimeoutMillis(poolConfig.getSocketTimeout().or(getSocketTimeout()).get());
    }

    AuthProvider authProvider = _authenticationCredentials != null
            ? new PlainTextAuthProvider(_authenticationCredentials.getUsername(), _authenticationCredentials.getPassword())
            : AuthProvider.NONE;

    return com.datastax.driver.core.Cluster.builder()
            .addContactPoints(contactPoints.toArray(new String[contactPoints.size()]))
            .withPort(_cqlPort)
            .withPoolingOptions(poolingOptions)
            .withSocketOptions(socketOptions)
            .withRetryPolicy(Policies.defaultRetryPolicy())
            .withAuthProvider(authProvider);
}
 

@Test
public void testNone() {
    final DatastaxAuthentication a = new DatastaxAuthentication.None();
    a.accept(builder);
    verify(builder, never()).withAuthProvider(any(AuthProvider.class));
}
 

/**
 * Sets authentication provider.
 *
 * @param provider Authentication provider.
 */
public void setAuthProvider(AuthProvider provider) {
    authProvider = provider;

    invalidate();
}
 

@Override
public AuthProvider build() {
    return new PlainTextAuthProvider(username, password);
}
 

@Test
public void shouldCreateCluster() throws Exception {

	CassandraServiceInfo info = new CassandraServiceInfo("local",
			Collections.singletonList("127.0.0.1"), 9142);

	Cluster cluster = creator.create(info, null);

	Configuration configuration = cluster.getConfiguration();

	assertThat(configuration.getProtocolOptions().getAuthProvider(),
			is(AuthProvider.NONE));
}
 

AuthProvider build();