// MongoOptions.java /** * Copyright (C) 2008 10gen Inc. * * Licensed 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 com.mongodb; import javax.net.SocketFactory; /** * Various settings for the driver. * Not thread safe. */ public class MongoOptions { public MongoOptions(){ reset(); } public void reset(){ connectionsPerHost = Bytes.CONNECTIONS_PER_HOST; threadsAllowedToBlockForConnectionMultiplier = 5; maxWaitTime = 1000 * 60 * 2; connectTimeout = 0; socketTimeout = 0; socketKeepAlive = false; autoConnectRetry = false; maxAutoConnectRetryTime = 0; slaveOk = false; safe = false; w = 0; wtimeout = 0; fsync = false; j = false; dbDecoderFactory = DefaultDBDecoder.FACTORY; dbEncoderFactory = DefaultDBEncoder.FACTORY; socketFactory = SocketFactory.getDefault(); description = null; } public MongoOptions copy() { MongoOptions m = new MongoOptions(); m.connectionsPerHost = connectionsPerHost; m.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier; m.maxWaitTime = maxWaitTime; m.connectTimeout = connectTimeout; m.socketTimeout = socketTimeout; m.socketKeepAlive = socketKeepAlive; m.autoConnectRetry = autoConnectRetry; m.maxAutoConnectRetryTime = maxAutoConnectRetryTime; m.slaveOk = slaveOk; m.safe = safe; m.w = w; m.wtimeout = wtimeout; m.fsync = fsync; m.j = j; m.dbDecoderFactory = dbDecoderFactory; m.dbEncoderFactory = dbEncoderFactory; m.socketFactory = socketFactory; m.description = description; return m; } /** * Helper method to return the appropriate WriteConcern instance based * on the current related options settings. **/ public WriteConcern getWriteConcern(){ // Ensure we only set writeconcern once; if non-default w, etc skip safe (implied) if ( w != 0 || wtimeout != 0 || fsync ) return new WriteConcern( w , wtimeout , fsync ); else if (safe) return WriteConcern.SAFE; else return WriteConcern.NORMAL; } /** * <p>The description for <code>Mongo</code> instances created with these options. This is used in various places like logging.</p> */ public String description; /** * The maximum number of connections allowed per host for this Mongo instance. * Those connections will be kept in a pool when idle. * Once the pool is exhausted, any operation requiring a connection will block waiting for an available connection. * Default is 10. * @see {@linkplain MongoOptions#threadsAllowedToBlockForConnectionMultiplier}</p> */ public int connectionsPerHost; /** * this multiplier, multiplied with the connectionsPerHost setting, gives the maximum number of threads that * may be waiting for a connection to become available from the pool. * All further threads will get an exception right away. * For example if connectionsPerHost is 10 and threadsAllowedToBlockForConnectionMultiplier is 5, then up to 50 threads can wait for a connection. * Default is 5. */ public int threadsAllowedToBlockForConnectionMultiplier; /** * The maximum wait time in milliseconds that a thread may wait for a connection to become available. * Default is 120,000. A value of 0 means that it will not wait. A negative value means to wait indefinitely. */ public int maxWaitTime; /** * The connection timeout in milliseconds. * It is used solely when establishing a new connection {@link java.net.Socket#connect(java.net.SocketAddress, int) } * Default is 0 and means no timeout. */ public int connectTimeout; /** * The socket timeout in milliseconds * It is used for I/O socket read and write operations {@link java.net.Socket#setSoTimeout(int)} * Default is 0 and means no timeout. */ public int socketTimeout; /** * This flag controls the socket keep alive feature that keeps a connection alive through firewalls {@link java.net.Socket#setKeepAlive(boolean)} * Default is false. */ public boolean socketKeepAlive; /** * If true, the driver will keep trying to connect to the same server in case that the socket cannot be established. * There is maximum amount of time to keep retrying, which is 15s by default. * This can be useful to avoid some exceptions being thrown when a server is down temporarily by blocking the operations. * It also can be useful to smooth the transition to a new master (so that a new master is elected within the retry time). * Note that when using this flag: * - for a replica set, the driver will trying to connect to the old master for that time, instead of failing over to the new one right away * - this does not prevent exception from being thrown in read/write operations on the socket, which must be handled by application * * Even if this flag is false, the driver already has mechanisms to automatically recreate broken connections and retry the read operations. * Default is false. */ public boolean autoConnectRetry; /** * The maximum amount of time in MS to spend retrying to open connection to the same server. * Default is 0, which means to use the default 15s if autoConnectRetry is on. */ public long maxAutoConnectRetryTime; /** * This flag specifies if the driver is allowed to read from secondary (slave) servers. * Specifically in the current implementation, the driver will avoid reading from the primary server and round robin requests to secondaries. * Driver also factors in the latency to secondaries when choosing a server. * Note that reading from secondaries can increase performance and reliability, but it may result in temporary inconsistent results. * Default is false. * * @deprecated Replaced in MongoDB 2.0/Java Driver 2.7 with ReadPreference.SECONDARY * @see com.mongodb.ReadPreference.SECONDARY */ @Deprecated public boolean slaveOk; /** * Override the DBCallback factory. Default is for the standard Mongo Java driver configuration. */ public DBDecoderFactory dbDecoderFactory; /** * Override the encoding factory. Default is for the standard Mongo Java driver configuration. */ public DBEncoderFactory dbEncoderFactory; /** * If <b>true</b> the driver will use a WriteConcern of WriteConcern.SAFE for all operations. * If w, wtimeout, fsync or j are specified, this setting is ignored. * Default is false. */ public boolean safe; /** * The "w" value, (number of writes), of the global WriteConcern. * Default is 0. */ public int w; /** * The "wtimeout" value of the global WriteConcern. * Default is 0. */ public int wtimeout; /** * The "fsync" value of the global WriteConcern. * true indicates writes should wait for data to be written to server data file * Default is false. */ public boolean fsync; /** * The "j" value of the global WriteConcern. * true indicates writes should wait for a journaling group commit * Default is false. */ public boolean j; /** * sets the socket factory for creating sockets to mongod * Default is SocketFactory.getDefault() */ public SocketFactory socketFactory; public String toString(){ StringBuilder buf = new StringBuilder(); buf.append( "description=" ).append( description ).append( ", " ); buf.append( "connectionsPerHost=" ).append( connectionsPerHost ).append( ", " ); buf.append( "threadsAllowedToBlockForConnectionMultiplier=" ).append( threadsAllowedToBlockForConnectionMultiplier ).append( ", " ); buf.append( "maxWaitTime=" ).append( maxWaitTime ).append( ", " ); buf.append( "connectTimeout=" ).append( connectTimeout ).append( ", " ); buf.append( "socketTimeout=" ).append( socketTimeout ).append( ", " ); buf.append( "socketKeepAlive=" ).append( socketKeepAlive ).append( ", " ); buf.append( "autoConnectRetry=" ).append( autoConnectRetry ).append( ", " ); buf.append( "maxAutoConnectRetryTime=" ).append( maxAutoConnectRetryTime ).append( ", " ); buf.append( "slaveOk=" ).append( slaveOk ).append( ", " ); buf.append( "safe=" ).append( safe ).append( ", " ); buf.append( "w=" ).append( w ).append( ", " ); buf.append( "wtimeout=" ).append( wtimeout ).append( ", " ); buf.append( "fsync=" ).append( fsync ).append( ", " ); buf.append( "j=" ).append( j ); return buf.toString(); } /** * @return The description for <code>Mongo</code> instances created with these options */ public synchronized String getDescription() { return description; } /** * * @param desc The description for <code>Mongo</code> instances created with these options */ public synchronized void setDescription(String desc) { description = desc; } /** * * @return the maximum number of connections allowed per host for this Mongo instance */ public synchronized int getConnectionsPerHost() { return connectionsPerHost; } /** * * @param connections sets the maximum number of connections allowed per host for this Mongo instance */ public synchronized void setConnectionsPerHost(int connections) { connectionsPerHost = connections; } /** * * @return the maximum number of threads that * may be waiting for a connection */ public synchronized int getThreadsAllowedToBlockForConnectionMultiplier() { return threadsAllowedToBlockForConnectionMultiplier; } /** * * @param this multiplied with connectionsPerHost, sets the maximum number of threads that * may be waiting for a connection */ public synchronized void setThreadsAllowedToBlockForConnectionMultiplier(int threads) { threadsAllowedToBlockForConnectionMultiplier = threads; } /** * * @return The maximum time in milliseconds that threads wait for a connection */ public synchronized int getMaxWaitTime() { return maxWaitTime; } /** * * @param timeMS set the maximum time in milliseconds that threads wait for a connection */ public synchronized void setMaxWaitTime(int timeMS) { maxWaitTime = timeMS; } /** * * @return the connection timeout in milliseconds. */ public synchronized int getConnectTimeout() { return connectTimeout; } /** * * @param timeoutMS set the connection timeout in milliseconds. */ public synchronized void setConnectTimeout(int timeoutMS) { connectTimeout = timeoutMS; } /** * * @return The socket timeout in milliseconds */ public synchronized int getSocketTimeout() { return socketTimeout; } /** * * @param timeoutMS set the socket timeout in milliseconds */ public synchronized void setSocketTimeout(int timeoutMS) { socketTimeout = timeoutMS; } /** * * @return connection keep-alive flag */ public synchronized boolean isSocketKeepAlive() { return socketKeepAlive; } /** * * @param keepAlive set connection keep-alive flag */ public synchronized void setSocketKeepAlive(boolean keepAlive) { socketKeepAlive = keepAlive; } /** * * @return keep trying connection flag */ public synchronized boolean isAutoConnectRetry() { return autoConnectRetry; } /** * * @param retry sets keep trying connection flag */ public synchronized void setAutoConnectRetry(boolean retry) { autoConnectRetry = retry; } /** * * @return max time in MS to retrying open connection */ public synchronized long getMaxAutoConnectRetryTime() { return maxAutoConnectRetryTime; } /** * * @param retryTimeMS set max time in MS to retrying open connection */ public synchronized void setMaxAutoConnectRetryTime(long retryTimeMS) { maxAutoConnectRetryTime = retryTimeMS; } /** * * @return the DBCallback decoding factory */ public synchronized DBDecoderFactory getDbDecoderFactory() { return dbDecoderFactory; } /** * * @param factory sets the DBCallback decoding factory */ public synchronized void setDbDecoderFactory(DBDecoderFactory factory) { dbDecoderFactory = factory; } /** * * @return the encoding factory */ public synchronized DBEncoderFactory getDbEncoderFactory() { return dbEncoderFactory; } /** * * @param factory sets the encoding factory */ public synchronized void setDbEncoderFactory(DBEncoderFactory factory) { dbEncoderFactory = factory; } /** * * @return true if driver uses WriteConcern.SAFE for all operations. */ public synchronized boolean isSafe() { return safe; } /** * * @param isSafe true if driver uses WriteConcern.SAFE for all operations. */ public synchronized void setSafe(boolean isSafe) { safe = isSafe; } /** * * @return value returns the number of writes of the global WriteConcern. */ public synchronized int getW() { return w; } /** * * @param val set the number of writes of the global WriteConcern. */ public synchronized void setW(int val) { w = val; } /** * * @return timeout for write operation */ public synchronized int getWtimeout() { return wtimeout; } /** * * @param timeoutMS sets timeout for write operation */ public synchronized void setWtimeout(int timeoutMS) { wtimeout = timeoutMS; } /** * * @return true if global write concern is set to fsync */ public synchronized boolean isFsync() { return fsync; } /** * * @param sync sets global write concern's fsync safe value */ public synchronized void setFsync(boolean sync) { fsync = sync; } /** * * @return true if global write concern is set to journal safe */ public synchronized boolean isJ() { return j; } /** * * @param safe sets global write concern's journal safe value */ public synchronized void setJ(boolean safe) { j = safe; } /** * * @return the socket factory for creating sockets to mongod */ public synchronized SocketFactory getSocketFactory() { return socketFactory; } /** * * @param factory sets the socket factory for creating sockets to mongod */ public synchronized void setSocketFactory(SocketFactory factory) { socketFactory = factory; } }