Example usage for com.mongodb MongoClientOptions.Builder maxConnectionIdleTime

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

  1. HOME
  2. Java
  3. com.mongodb
  4. com.mongodb.*
  5. MongoClientOptions.Builder
  6. maxConnectionIdleTime

Introduction

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

Prototype

int maxConnectionIdleTime

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

Click Source Link

Usage

From source file:com.sitewhere.mongodb.MongoDbClient.java

License:Open Source License

@Override
public void initialize(ILifecycleProgressMonitor monitor) throws SiteWhereException {
    try {/*  w  w w  .  j  av a  2s .  c o  m*/
        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
        builder.maxConnectionIdleTime(60 * 60 * 1000); // 1hour

        getLogger().info("MongoDB Connection: hosts=" + getHostname().getValue() + " ports="
                + getConfiguration().getPort() + " replicaSet=" + getConfiguration().getReplicaSetName());

        // Parse hostname(s) and port(s) into address list.
        List<ServerAddress> addresses = parseServerAddresses();

        // Indicator for whether a replica set is being used.
        boolean isUsingReplicaSet = ((addresses.size() > 1)
                && (!StringUtils.isEmpty(getConfiguration().getReplicaSetName())));

        if (isUsingReplicaSet) {
            getLogger().info("MongoDB using replicated mode.");
        } else {
            getLogger().info("MongoDB using standalone mode.");
        }

        // Handle authenticated access.
        if ((getConfiguration().getUsername() != null) && (getConfiguration().getPassword() != null)) {
            MongoCredential credential = MongoCredential.createCredential(getConfiguration().getUsername(),
                    getConfiguration().getAuthDatabaseName(), getConfiguration().getPassword().toCharArray());
            if (isUsingReplicaSet) {
                this.client = new MongoClient(addresses, Arrays.asList(credential), builder.build());
            } else {
                this.client = new MongoClient(addresses.get(0), Arrays.asList(credential), builder.build());
            }
        }

        // Handle unauthenticated access.
        else {
            if (isUsingReplicaSet) {
                this.client = new MongoClient(addresses, builder.build());
            } else {
                this.client = new MongoClient(addresses.get(0), builder.build());
            }
        }

        // Handle automatic configuration of replication.
        if ((isUsingReplicaSet) && (getConfiguration().isAutoConfigureReplication())) {
            doAutoConfigureReplication(addresses);
        }

        // Force interaction to test connectivity.
        getDatabase().listCollectionNames();
    } catch (MongoTimeoutException e) {
        throw new SiteWhereException("Timed out connecting to MongoDB instance. "
                + "Verify that MongoDB is running on " + getHostname().getValue() + ":"
                + getConfiguration().getPort() + " and restart server.", e);
    }
}

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);//from  w  w w  . j a  va2s .  co 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.apache.beam.sdk.io.mongodb.MongoDbIO.java

License:Apache License

private static MongoClientOptions.Builder getOptions(int maxConnectionIdleTime, boolean sslEnabled,
        boolean sslInvalidHostNameAllowed) {
    MongoClientOptions.Builder optionsBuilder = new MongoClientOptions.Builder();
    optionsBuilder.maxConnectionIdleTime(maxConnectionIdleTime);
    if (sslEnabled) {
        optionsBuilder.sslEnabled(sslEnabled).sslInvalidHostNameAllowed(sslInvalidHostNameAllowed)
                .sslContext(SSLUtils.ignoreSSLCertificate());
    }//from   ww  w.  ja v  a  2s.  c o m
    return optionsBuilder;
}

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   w  w  w . j av a  2 s.co m
 *
 * @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  w  w w.  java 2  s .  com
    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;
}