Example usage for com.mongodb MongoClientOptions.Builder maxConnectionLifeTime

List of usage examples for com.mongodb MongoClientOptions.Builder maxConnectionLifeTime

Introduction

In this page you can find the example usage for com.mongodb MongoClientOptions.Builder maxConnectionLifeTime.

Prototype

int maxConnectionLifeTime

To view the source code for com.mongodb MongoClientOptions.Builder maxConnectionLifeTime.

Click Source Link

Usage

From source file:io.gravitee.repository.mongodb.common.MongoFactory.java

License:Apache License

private MongoClientOptions.Builder builder() {
    MongoClientOptions.Builder builder = MongoClientOptions.builder();

    builder.writeConcern(WriteConcern.SAFE);

    Integer connectionsPerHost = readPropertyValue(propertyPrefix + "connectionsPerHost", Integer.class);
    Integer connectTimeout = readPropertyValue(propertyPrefix + "connectTimeout", Integer.class, 500);
    Integer maxWaitTime = readPropertyValue(propertyPrefix + "maxWaitTime", Integer.class);
    Integer socketTimeout = readPropertyValue(propertyPrefix + "socketTimeout", Integer.class, 500);
    Boolean socketKeepAlive = readPropertyValue(propertyPrefix + "socketKeepAlive", Boolean.class);
    Integer maxConnectionLifeTime = readPropertyValue(propertyPrefix + "maxConnectionLifeTime", Integer.class);
    Integer maxConnectionIdleTime = readPropertyValue(propertyPrefix + "maxConnectionIdleTime", Integer.class);

    // We do not want to wait for a server
    Integer serverSelectionTimeout = readPropertyValue(propertyPrefix + "serverSelectionTimeout", Integer.class,
            0);/* w w  w  .j ava 2  s  . c o m*/
    Integer minHeartbeatFrequency = readPropertyValue(propertyPrefix + "minHeartbeatFrequency", Integer.class);
    String description = readPropertyValue(propertyPrefix + "description", String.class, "gravitee.io");
    Integer heartbeatConnectTimeout = readPropertyValue(propertyPrefix + "heartbeatConnectTimeout",
            Integer.class, 1000);
    Integer heartbeatFrequency = readPropertyValue(propertyPrefix + "heartbeatFrequency", Integer.class);
    Integer heartbeatSocketTimeout = readPropertyValue(propertyPrefix + "heartbeatSocketTimeout",
            Integer.class);
    Integer localThreshold = readPropertyValue(propertyPrefix + "localThreshold", Integer.class);
    Integer minConnectionsPerHost = readPropertyValue(propertyPrefix + "minConnectionsPerHost", Integer.class);
    Boolean sslEnabled = readPropertyValue(propertyPrefix + "sslEnabled", Boolean.class);
    Integer threadsAllowedToBlockForConnectionMultiplier = readPropertyValue(
            propertyPrefix + "threadsAllowedToBlockForConnectionMultiplier", Integer.class);
    Boolean cursorFinalizerEnabled = readPropertyValue(propertyPrefix + "cursorFinalizerEnabled",
            Boolean.class);

    if (connectionsPerHost != null)
        builder.connectionsPerHost(connectionsPerHost);
    if (maxWaitTime != null)
        builder.maxWaitTime(maxWaitTime);
    if (connectTimeout != null)
        builder.connectTimeout(connectTimeout);
    if (socketTimeout != null)
        builder.socketTimeout(socketTimeout);
    if (socketKeepAlive != null)
        builder.socketKeepAlive(socketKeepAlive);
    if (maxConnectionLifeTime != null)
        builder.maxConnectionLifeTime(maxConnectionLifeTime);
    if (maxConnectionIdleTime != null)
        builder.maxConnectionIdleTime(maxConnectionIdleTime);
    if (minHeartbeatFrequency != null)
        builder.minHeartbeatFrequency(minHeartbeatFrequency);
    if (description != null)
        builder.description(description);
    if (heartbeatConnectTimeout != null)
        builder.heartbeatConnectTimeout(heartbeatConnectTimeout);
    if (heartbeatFrequency != null)
        builder.heartbeatFrequency(heartbeatFrequency);
    if (heartbeatSocketTimeout != null)
        builder.heartbeatSocketTimeout(heartbeatSocketTimeout);
    if (localThreshold != null)
        builder.localThreshold(localThreshold);
    if (minConnectionsPerHost != null)
        builder.minConnectionsPerHost(minConnectionsPerHost);
    if (sslEnabled != null)
        builder.sslEnabled(sslEnabled);
    if (threadsAllowedToBlockForConnectionMultiplier != null)
        builder.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier);
    if (cursorFinalizerEnabled != null)
        builder.cursorFinalizerEnabled(cursorFinalizerEnabled);
    if (serverSelectionTimeout != null)
        builder.serverSelectionTimeout(serverSelectionTimeout);

    return builder;
}

From source file:org.wso2.extension.siddhi.store.mongodb.util.MongoTableUtils.java

License:Open Source License

/**
 * Utility method which can be used to create MongoClientOptionsBuilder from values defined in the
 * deployment yaml file./*from  ww w.j a va2 s .  com*/
 *
 * @param storeAnnotation the source annotation which contains the needed parameters.
 * @param configReader    {@link ConfigReader} Configuration Reader
 * @return MongoClientOptions.Builder
 */
public static MongoClientOptions.Builder extractMongoClientOptionsBuilder(Annotation storeAnnotation,
        ConfigReader configReader) {

    MongoClientOptions.Builder mongoClientOptionsBuilder = MongoClientOptions.builder();
    try {
        mongoClientOptionsBuilder.connectionsPerHost(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.CONNECTIONS_PER_HOST, "100")));
        mongoClientOptionsBuilder.connectTimeout(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.CONNECT_TIMEOUT, "10000")));
        mongoClientOptionsBuilder.heartbeatConnectTimeout(Integer
                .parseInt(configReader.readConfig(MongoTableConstants.HEARTBEAT_CONNECT_TIMEOUT, "20000")));
        mongoClientOptionsBuilder.heartbeatSocketTimeout(Integer
                .parseInt(configReader.readConfig(MongoTableConstants.HEARTBEAT_SOCKET_TIMEOUT, "20000")));
        mongoClientOptionsBuilder.heartbeatFrequency(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.HEARTBEAT_FREQUENCY, "10000")));
        mongoClientOptionsBuilder.localThreshold(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.LOCAL_THRESHOLD, "15")));
        mongoClientOptionsBuilder.maxWaitTime(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.MAX_WAIT_TIME, "120000")));
        mongoClientOptionsBuilder.minConnectionsPerHost(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.MIN_CONNECTIONS_PER_HOST, "0")));
        mongoClientOptionsBuilder.minHeartbeatFrequency(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.MIN_HEARTBEAT_FREQUENCY, "500")));
        mongoClientOptionsBuilder.serverSelectionTimeout(Integer
                .parseInt(configReader.readConfig(MongoTableConstants.SERVER_SELECTION_TIMEOUT, "30000")));
        mongoClientOptionsBuilder.socketTimeout(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.SOCKET_TIMEOUT, "0")));
        mongoClientOptionsBuilder.threadsAllowedToBlockForConnectionMultiplier(
                Integer.parseInt(configReader.readConfig(MongoTableConstants.THREADS_ALLOWED_TO_BLOCK, "5")));
        mongoClientOptionsBuilder.socketKeepAlive(
                Boolean.parseBoolean(configReader.readConfig(MongoTableConstants.SOCKET_KEEP_ALIVE, "false")));
        mongoClientOptionsBuilder.sslEnabled(
                Boolean.parseBoolean(configReader.readConfig(MongoTableConstants.SSL_ENABLED, "false")));
        mongoClientOptionsBuilder.cursorFinalizerEnabled(Boolean
                .parseBoolean(configReader.readConfig(MongoTableConstants.CURSOR_FINALIZER_ENABLED, "true")));
        mongoClientOptionsBuilder.readPreference(ReadPreference
                .valueOf(configReader.readConfig(MongoTableConstants.READ_PREFERENCE, "primary")));
        mongoClientOptionsBuilder.writeConcern(WriteConcern
                .valueOf(configReader.readConfig(MongoTableConstants.WRITE_CONCERN, "acknowledged")));

        String readConcern = configReader.readConfig(MongoTableConstants.READ_CONCERN, "DEFAULT");
        if (!readConcern.matches("DEFAULT")) {
            mongoClientOptionsBuilder.readConcern(new ReadConcern(ReadConcernLevel.fromString(readConcern)));
        }

        int maxConnectionIdleTime = Integer
                .parseInt(configReader.readConfig(MongoTableConstants.MAX_CONNECTION_IDLE_TIME, "0"));
        if (maxConnectionIdleTime != 0) {
            mongoClientOptionsBuilder.maxConnectionIdleTime(maxConnectionIdleTime);
        }

        int maxConnectionLifeTime = Integer
                .parseInt(configReader.readConfig(MongoTableConstants.MAX_CONNECTION_LIFE_TIME, "0"));
        if (maxConnectionIdleTime != 0) {
            mongoClientOptionsBuilder.maxConnectionLifeTime(maxConnectionLifeTime);
        }

        String requiredReplicaSetName = configReader.readConfig(MongoTableConstants.REQUIRED_REPLICA_SET_NAME,
                "");
        if (!requiredReplicaSetName.equals("")) {
            mongoClientOptionsBuilder.requiredReplicaSetName(requiredReplicaSetName);
        }

        String applicationName = configReader.readConfig(MongoTableConstants.APPLICATION_NAME, "");
        if (!applicationName.equals("")) {
            mongoClientOptionsBuilder.applicationName(applicationName);
        }

        String secureConnectionEnabled = storeAnnotation
                .getElement(MongoTableConstants.ANNOTATION_ELEMENT_SECURE_CONNECTION);
        secureConnectionEnabled = secureConnectionEnabled == null ? "false" : secureConnectionEnabled;

        if (secureConnectionEnabled.equalsIgnoreCase("true")) {
            mongoClientOptionsBuilder.sslEnabled(true);
            String trustStore = storeAnnotation.getElement(MongoTableConstants.ANNOTATION_ELEMENT_TRUSTSTORE);
            trustStore = trustStore == null ? configReader.readConfig("trustStore", DEFAULT_TRUST_STORE_FILE)
                    : trustStore;
            trustStore = resolveCarbonHome(trustStore);

            String trustStorePassword = storeAnnotation
                    .getElement(MongoTableConstants.ANNOTATION_ELEMENT_TRUSTSTOREPASS);
            trustStorePassword = trustStorePassword == null
                    ? configReader.readConfig("trustStorePassword", DEFAULT_TRUST_STORE_PASSWORD)
                    : trustStorePassword;

            String keyStore = storeAnnotation.getElement(MongoTableConstants.ANNOTATION_ELEMENT_KEYSTORE);
            keyStore = keyStore == null ? configReader.readConfig("keyStore", DEFAULT_KEY_STORE_FILE)
                    : keyStore;
            keyStore = resolveCarbonHome(keyStore);

            String keyStorePassword = storeAnnotation
                    .getElement(MongoTableConstants.ANNOTATION_ELEMENT_STOREPASS);
            keyStorePassword = keyStorePassword == null
                    ? configReader.readConfig("keyStorePassword", DEFAULT_KEY_STORE_PASSWORD)
                    : keyStorePassword;

            mongoClientOptionsBuilder.socketFactory(MongoTableUtils.extractSocketFactory(trustStore,
                    trustStorePassword, keyStore, keyStorePassword));
        }
        return mongoClientOptionsBuilder;
    } catch (IllegalArgumentException e) {
        throw new MongoTableException("Values Read from config readers have illegal values : ", e);
    }
}

From source file:streamflow.datastore.mongodb.config.MongoDatastoreModule.java

License:Apache License

@Provides
public Mongo providesMongoClient(DatastoreConfig datastoreConfig) {
    MongoClient mongoClient = null;/*from  www .  j a v  a 2  s  . co m*/
    MongoClientOptions.Builder clientOptions = MongoClientOptions.builder();

    String serverAddressHost = datastoreConfig.getProperty("host", String.class);
    if (serverAddressHost == null) {
        serverAddressHost = "localhost";
    }

    Integer serverAddressPort = datastoreConfig.getProperty("port", Integer.class);
    if (serverAddressPort == null) {
        serverAddressPort = 27017;
    }

    Integer acceptableLatencyDifference = datastoreConfig.getProperty("acceptableLatencyDifference",
            Integer.class);
    if (acceptableLatencyDifference != null) {
        clientOptions.acceptableLatencyDifference(acceptableLatencyDifference);
    }

    Integer connectTimeout = datastoreConfig.getProperty("connectTimeout", Integer.class);
    if (connectTimeout != null) {
        clientOptions.connectTimeout(connectTimeout);
    }

    Integer connectionsPerHost = datastoreConfig.getProperty("connectionsPerHost", Integer.class);
    if (connectionsPerHost != null) {
        clientOptions.connectionsPerHost(connectionsPerHost);
    }

    Boolean cursorFinalizerEnabled = datastoreConfig.getProperty("acceptableLatencyDifference", Boolean.class);
    if (cursorFinalizerEnabled != null) {
        clientOptions.cursorFinalizerEnabled(cursorFinalizerEnabled);
    }

    Integer heartbeatConnectRetryFrequency = datastoreConfig.getProperty("heartbeatConnectRetryFrequency",
            Integer.class);
    if (heartbeatConnectRetryFrequency != null) {
        clientOptions.heartbeatConnectRetryFrequency(heartbeatConnectRetryFrequency);
    }

    Integer heartbeatConnectTimeout = datastoreConfig.getProperty("heartbeatConnectTimeout", Integer.class);
    if (heartbeatConnectTimeout != null) {
        clientOptions.heartbeatConnectTimeout(heartbeatConnectTimeout);
    }

    Integer heartbeatFrequency = datastoreConfig.getProperty("heartbeatFrequency", Integer.class);
    if (heartbeatFrequency != null) {
        clientOptions.heartbeatFrequency(heartbeatFrequency);
    }

    Integer heartbeatSocketTimeout = datastoreConfig.getProperty("heartbeatSocketTimeout", Integer.class);
    if (heartbeatSocketTimeout != null) {
        clientOptions.heartbeatSocketTimeout(heartbeatSocketTimeout);
    }

    Integer heartbeatThreadCount = datastoreConfig.getProperty("heartbeatThreadCount", Integer.class);
    if (heartbeatThreadCount != null) {
        clientOptions.heartbeatThreadCount(heartbeatThreadCount);
    }

    Integer maxConnectionIdleTime = datastoreConfig.getProperty("maxConnectionIdleTime", Integer.class);
    if (maxConnectionIdleTime != null) {
        clientOptions.maxConnectionIdleTime(maxConnectionIdleTime);
    }

    Integer maxConnectionLifeTime = datastoreConfig.getProperty("maxConnectionLifeTime", Integer.class);
    if (maxConnectionLifeTime != null) {
        clientOptions.maxConnectionLifeTime(maxConnectionLifeTime);
    }

    Integer maxWaitTime = datastoreConfig.getProperty("maxWaitTime", Integer.class);
    if (maxWaitTime != null) {
        clientOptions.maxWaitTime(maxWaitTime);
    }

    Integer minConnectionsPerHost = datastoreConfig.getProperty("minConnectionsPerHost", Integer.class);
    if (minConnectionsPerHost != null) {
        clientOptions.minConnectionsPerHost(minConnectionsPerHost);
    }

    Boolean socketKeepAlive = datastoreConfig.getProperty("socketKeepAlive", Boolean.class);
    if (socketKeepAlive != null) {
        clientOptions.socketKeepAlive(socketKeepAlive);
    }

    Integer socketTimeout = datastoreConfig.getProperty("socketTimeout", Integer.class);
    if (socketTimeout != null) {
        clientOptions.socketTimeout(socketTimeout);
    }

    Integer threadsAllowedToBlockForConnectionMultiplier = datastoreConfig
            .getProperty("threadsAllowedToBlockForConnectionMultiplier", Integer.class);
    if (threadsAllowedToBlockForConnectionMultiplier != null) {
        clientOptions
                .threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier);
    }

    try {
        ServerAddress serverAddress = new ServerAddress(serverAddressHost, serverAddressPort);

        // Initialize the Mongo connection with the specified address and options
        mongoClient = new MongoClient(serverAddress, clientOptions.build());
    } catch (UnknownHostException ex) {
        LOG.error("Exception occurred while building Mongo client connection", ex);
    }

    return mongoClient;
}