CXX-151 Backport server rc2..rc3 changes

Author: acmorrow

src/mongo/client/connpool.cpp

@@ -41,18 +41,23 @@ namespace mongo {
         }
     }
 
-    void PoolForHost::done( DBConnectionPool * pool, DBClientBase * c ) {
-        if (c->isFailed()) {
-            reportBadConnectionAt(c->getSockCreationMicroSec());
-            pool->onDestroy(c);
-            delete c;
-        }
-        else if (_pool.size() >= _maxPerHost ||
-                c->getSockCreationMicroSec() < _minValidCreationTimeMicroSec) {
+    void PoolForHost::done(DBConnectionPool* pool, DBClientBase* c) {
+
+        bool isFailed = c->isFailed();
+
+        // Remember that this host had a broken connection for later
+        if (isFailed) reportBadConnectionAt(c->getSockCreationMicroSec());
+
+        if (isFailed ||
+            // Another (later) connection was reported as broken to this host
+            (c->getSockCreationMicroSec() < _minValidCreationTimeMicroSec) ||
+            // We have a pool size that we need to enforce
+            (_maxPoolSize >= 0 && static_cast<int>(_pool.size()) >= _maxPoolSize)) {
             pool->onDestroy(c);
             delete c;
         }
         else {
+            // The connection is probably fine, save for later
             _pool.push(c);
         }
     }
@@ -166,23 +171,25 @@ namespace mongo {
         }
     }
 
-    unsigned PoolForHost::_maxPerHost = 50;
-
     // ------ DBConnectionPool ------
 
     DBConnectionPool pool;
 
-    DBConnectionPool::DBConnectionPool() 
+    const int PoolForHost::kPoolSizeUnlimited(-1);
+
+    DBConnectionPool::DBConnectionPool()
         : _mutex("DBConnectionPool") , 
           _name( "dbconnectionpool" ) , 
-          _hooks( new list<DBConnectionHook*>() ) { 
+          _maxPoolSize(PoolForHost::kPoolSizeUnlimited) ,
+          _hooks( new list<DBConnectionHook*>() ) {
     }
 
     DBClientBase* DBConnectionPool::_get(const string& ident , double socketTimeout ) {
         uassert(17382, "Can't use connection pool during shutdown",
                 !inShutdown());
         scoped_lock L(_mutex);
         PoolForHost& p = _pools[PoolKey(ident,socketTimeout)];
+        p.setMaxPoolSize(_maxPoolSize);
         p.initializeHostName(ident);
         return p.get( this , socketTimeout );
     }
@@ -191,6 +198,7 @@ namespace mongo {
         {
             scoped_lock L(_mutex);
             PoolForHost& p = _pools[PoolKey(host,socketTimeout)];
+            p.setMaxPoolSize(_maxPoolSize);
             p.initializeHostName(host);
             p.createdOne( conn );
         }

src/mongo/client/connpool.h

@@ -35,18 +35,38 @@ namespace mongo {
      */
     class MONGO_CLIENT_API PoolForHost {
     public:
-        PoolForHost()
-            : _created(0), _minValidCreationTimeMicroSec(0) {}
 
-        PoolForHost( const PoolForHost& other ) {
+        // Sentinel value indicating pool has no cleanup limit
+        static const int kPoolSizeUnlimited;
+
+        PoolForHost() :
+            _created(0),
+            _minValidCreationTimeMicroSec(0),
+            _type(ConnectionString::INVALID),
+            _maxPoolSize(kPoolSizeUnlimited) {
+        }
+
+        PoolForHost(const PoolForHost& other) :
+            _created(other._created),
+            _minValidCreationTimeMicroSec(other._minValidCreationTimeMicroSec),
+            _type(other._type),
+            _maxPoolSize(other._maxPoolSize) {
+            verify(_created == 0);
             verify(other._pool.size() == 0);
-            _created = other._created;
-            _minValidCreationTimeMicroSec = other._minValidCreationTimeMicroSec;
-            verify( _created == 0 );
         }
 
         ~PoolForHost();
 
+        /**
+         * Returns the maximum number of connections stored in the pool
+         */
+        int getMaxPoolSize() { return _maxPoolSize; }
+
+        /**
+         * Sets the maximum number of connections stored in the pool
+         */
+        void setMaxPoolSize( int maxPoolSize ) { _maxPoolSize = maxPoolSize; }
+
         int numAvailable() const { return (int)_pool.size(); }
 
         void createdOne( DBClientBase * base );
@@ -85,8 +105,6 @@ namespace mongo {
          */
         void initializeHostName(const std::string& hostName);
 
-        static void setMaxPerHost( unsigned max ) { _maxPerHost = max; }
-        static unsigned getMaxPerHost() { return _maxPerHost; }
     private:
 
         struct StoredConnection {
@@ -105,7 +123,8 @@ namespace mongo {
         uint64_t _minValidCreationTimeMicroSec;
         ConnectionString::ConnectionType _type;
 
-        static unsigned _maxPerHost;
+        // The maximum number of connections we'll save in the pool
+        int _maxPoolSize;
     };
 
     class DBConnectionHook {
@@ -141,6 +160,22 @@ namespace mongo {
         /** right now just controls some asserts.  defaults to "dbconnectionpool" */
         void setName( const string& name ) { _name = name; }
 
+        /**
+         * Returns the maximum number of connections pooled per-host
+         *
+         * This setting only applies to new host connection pools, previously-pooled host pools are
+         * unaffected.
+         */
+        int getMaxPoolSize() { return _maxPoolSize; }
+
+        /**
+         * Sets the maximum number of connections pooled per-host.
+         *
+         * This setting only applies to new host connection pools, previously-pooled host pools are
+         * unaffected.
+         */
+        void setMaxPoolSize( int maxPoolSize ) { _maxPoolSize = maxPoolSize; }
+
         void onCreate( DBClientBase * conn );
         void onHandedOut( DBClientBase * conn );
         void onDestroy( DBClientBase * conn );
@@ -204,6 +239,11 @@ namespace mongo {
         mongo::mutex _mutex;
         string _name;
 
+        // The maximum number of connections we'll save in the pool per-host
+        // PoolForHost::kPoolSizeUnlimited is a sentinel value meaning "no limit"
+        // 0 effectively disables the pool
+        int _maxPoolSize;
+
         PoolMap _pools;
 
         // pointers owned by me, right now they leak on shutdown

src/mongo/client/gridfs.cpp

@@ -38,7 +38,7 @@
 
 namespace mongo {
 
-    const unsigned DEFAULT_CHUNK_SIZE = 256 * 1024;
+    const unsigned DEFAULT_CHUNK_SIZE = 255 * 1024;
 
     GridFSChunk::GridFSChunk( BSONObj o ) {
         _data = o;

src/mongo/client/init.cpp

@@ -20,6 +20,7 @@
 #include <cstdlib>
 
 #include "mongo/base/initializer.h"
+#include "mongo/client/connpool.h"
 #include "mongo/client/replica_set_monitor.h"
 #include "mongo/util/background.h"
 
@@ -47,6 +48,10 @@ namespace client {
         if (!result.isOK())
             return result;
 
+        // Setup default pool parameters
+        mongo::pool.setName("connection pool");
+        mongo::pool.setMaxPoolSize(50);
+
         PeriodicTask::startRunningPeriodicTasks();
 
         return Status::OK();

src/mongo/client/sasl_client_session.cpp

@@ -44,7 +44,7 @@ namespace {
 
     void* saslOurCalloc(SaslAllocSize count, SaslAllocSize size) {
         void* ptr = calloc(count, size);
-        if (!ptr) printStackAndExit(0);
+        if (!ptr) abort();
         return ptr;
     }
 

src/mongo/client/scoped_db_conn_test.cpp

@@ -250,11 +250,11 @@ namespace mongo {
             DummyServerFixture() {
                 _server = new TCPServer(TARGET_PORT);
                 _thread = new boost::thread(boost::ref(*_server));
-                _maxPoolSizePerHost = mongo::PoolForHost::getMaxPerHost();
+                _maxPoolSizePerHost = mongo::pool.getMaxPoolSize();
             }
 
             ~DummyServerFixture() {
-                mongo::PoolForHost::setMaxPerHost(_maxPoolSizePerHost);
+                mongo::pool.setMaxPoolSize(_maxPoolSizePerHost);
                 mongo::ScopedDbConnection::clearPool();
 
                 _server->stop();
@@ -390,7 +390,7 @@ namespace mongo {
     }
 
     TEST_F(DummyServerFixture, InvalidateBadConnEvenWhenPoolIsFull) {
-        mongo::PoolForHost::setMaxPerHost(2);
+        mongo::pool.setMaxPoolSize(2);
 
         ScopedDbConnection conn1(TARGET_HOST);
         ScopedDbConnection conn2(TARGET_HOST);

src/mongo/util/allocator.h

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "mongo/util/signal_handlers.h"
+#include <stdlib.h>
 
 // we need the "real" malloc here
 #include "mongo/client/undef_macros.h"
@@ -26,13 +26,13 @@ namespace mongo {
 
     inline void * ourmalloc(size_t size) {
         void *x = malloc(size);
-        if ( x == 0 ) printStackAndExit(0);
+        if ( x == 0 ) abort();
         return x;
     }
 
     inline void * ourrealloc(void *ptr, size_t size) {
         void *x = realloc(ptr, size);
-        if ( x == 0 ) printStackAndExit(0);
+        if ( x == 0 ) abort();
         return x;
     }
 

src/mongo/util/log.cpp

@@ -38,7 +38,6 @@ using namespace std;
 // TODO: Extra log context appending, and re-enable log_user_*.js
 // TODO: Eliminate cout/cerr.
 // TODO: LogIndent (for mongodump).
-// TODO: Eliminate rawOut.
 
 namespace mongo {
 
@@ -116,41 +115,6 @@ namespace mongo {
         return s.str();
     }
 
-    namespace {
-        bool rawOutToStderr = false;
-    } // namespace
-
-    void setRawOutToStderr() {
-        rawOutToStderr = true;
-    }
-
-    /*
-     * NOTE(schwerin): Called from signal handlers; should not be taking locks or allocating
-     * memory.
-     */
-    void rawOut(const StringData &s) {
-        // Can't use STDxxx_FILENO macros since they don't exist on windows.
-        const int fd = rawOutToStderr
-                        ? 2 // STDERR_FILENO
-                        : 1 // STDOUT_FILENO
-                        ;
-
-        const char* ptr = s.rawData();
-        size_t bytesRemaining = s.size();
-        while (bytesRemaining) {
-#ifdef _WIN32
-            int ret = _write(fd, ptr, bytesRemaining);
-#else
-            ssize_t ret = write(fd, ptr, bytesRemaining);
-#endif
-            if (ret < 0)
-                return; // Nothing to do. Can't even log since that is what is failing.
-
-            ptr += ret;
-            bytesRemaining -= ret;
-        }
-    }
-
     void logContext(const char *errmsg) {
         if ( errmsg ) {
             problem() << errmsg << endl;

src/mongo/util/log.h

@@ -127,19 +127,6 @@ namespace logger {
     extern Tee* const startupWarningsLog; // Things put here get reported in MMS
 
     string errnoWithDescription(int errorcode = -1);
-    void rawOut( const StringData &s );
-
-    /*
-     * Redirects the output of "rawOut" to stderr.  The default is stdout.
-     *
-     * NOTE: This needs to be here because the tools such as mongoexport and mongodump sometimes
-     * send data to stdout and share this code, so they need to be able to redirect output to
-     * stderr.  Eventually rawOut should be replaced with something better and our tools should not
-     * need to call internal server shutdown functions.
-     *
-     * NOTE: This function is not thread safe and should not be called from a multithreaded context.
-     */
-    void setRawOutToStderr();
 
     /**
      * Write the current context (backtrace), along with the optional "msg".

src/mongo/util/net/sock.cpp

@@ -874,7 +874,7 @@ namespace mongo {
                         << " remote host " << remoteString() << ")" << endl;
                 DEV {
                     std::string hex = hexdump(testBuf, recvd);
-                    error() << "Hex Dump of stale log data: " << hex << endl;
+                    error() << "Hex dump of stale log data: " << hex << endl;
                 }
                 dassert( false );
             }

src/mongo/util/net/ssl_manager.cpp

@@ -589,7 +589,7 @@ namespace mongo {
 
         X509* x509 = PEM_read_bio_X509(in, NULL, &SSLManager::password_cb, this);
         if (NULL == x509) {
-            error() << "cannot retreive certificate from keyfile: " << keyFile << ' ' <<
+            error() << "cannot retrieve certificate from keyfile: " << keyFile << ' ' <<
                 getSSLErrorMessage(ERR_get_error()) << endl; 
             return false;
         }

src/mongo/util/net/ssl_options.h

@@ -76,5 +76,11 @@ namespace mongo {
 
     Status storeSSLServerOptions(const moe::Environment& params);
 
+    /**
+     * Canonicalize SSL options for the given environment that have different representations with
+     * the same logical meaning
+     */
+    Status canonicalizeSSLServerOptions(moe::Environment* params);
+
     Status storeSSLClientOptions(const moe::Environment& params);
 }