1 files changed, 30 insertions, 19 deletions

diff --git a/db/repl/connections.h b/db/repl/connections.h
index cdf2fad..7e7bfe5 100644
--- a/db/repl/connections.h
+++ b/db/repl/connections.h
@@ -1,4 +1,4 @@
-// @file 
+// @file
 
 /*
  *    Copyright (C) 2010 10gen Inc.
@@ -20,11 +20,12 @@
 
 #include <map>
 #include "../../client/dbclient.h"
+#include "../security_key.h"
 
-namespace mongo { 
+namespace mongo {
 
-    /** here we keep a single connection (with reconnect) for a set of hosts, 
-        one each, and allow one user at a time per host.  if in use already for that 
+    /** here we keep a single connection (with reconnect) for a set of hosts,
+        one each, and allow one user at a time per host.  if in use already for that
         host, we block.  so this is an easy way to keep a 1-deep pool of connections
         that many threads can share.
 
@@ -39,35 +40,37 @@ namespace mongo {
         throws exception on connect error (but fine to try again later with a new
         scopedconn object for same host).
     */
-    class ScopedConn { 
+    class ScopedConn {
     public:
         /** throws assertions if connect failure etc. */
         ScopedConn(string hostport);
         ~ScopedConn();
 
         /* If we were to run a query and not exhaust the cursor, future use of the connection would be problematic.
-           So here what we do is wrapper known safe methods and not allow cursor-style queries at all.  This makes 
+           So here what we do is wrapper known safe methods and not allow cursor-style queries at all.  This makes
            ScopedConn limited in functionality but very safe.  More non-cursor wrappers can be added here if needed.
            */
 
         bool runCommand(const string &dbname, const BSONObj& cmd, BSONObj &info, int options=0) {
             return conn()->runCommand(dbname, cmd, info, options);
         }
-        unsigned long long count(const string &ns) { 
-            return conn()->count(ns); 
+        unsigned long long count(const string &ns) {
+            return conn()->count(ns);
         }
-        BSONObj findOne(const string &ns, const Query& q, const BSONObj *fieldsToReturn = 0, int queryOptions = 0) { 
+        BSONObj findOne(const string &ns, const Query& q, const BSONObj *fieldsToReturn = 0, int queryOptions = 0) {
             return conn()->findOne(ns, q, fieldsToReturn, queryOptions);
         }
+        void setTimeout(double to) {
+            conn()->setSoTimeout(to);
+        }
 
     private:
         auto_ptr<scoped_lock> connLock;
-        static mutex mapMutex;
-        struct X { 
-            mutex z;
+        static mongo::mutex mapMutex;
+        struct X {
+            mongo::mutex z;
             DBClientConnection cc;
-            X() : z("X"), cc(/*reconnect*/ true, 0, 
-                             /*timeout*/ theReplSet ? theReplSet->config().ho.heartbeatTimeoutMillis/1000.0 : 10.0) { 
+            X() : z("X"), cc(/*reconnect*/ true, 0, /*timeout*/ 10.0) {
                 cc._logLevel = 2;
             }
         } *x;
@@ -87,22 +90,30 @@ namespace mongo {
                 connLock.reset( new scoped_lock(x->z) );
             }
         }
-        if( !first ) { 
+        if( !first ) {
             connLock.reset( new scoped_lock(x->z) );
             return;
         }
 
         // we already locked above...
         string err;
-        x->cc.connect(hostport, err);
+        if (!x->cc.connect(hostport, err)) {
+            log() << "couldn't connect to " << hostport << ": " << err << rsLog;
+            return;
+        }
+
+        if (!noauth && !x->cc.auth("local", internalSecurity.user, internalSecurity.pwd, err, false)) {
+            log() << "could not authenticate against " << conn()->toString() << ", " << err << rsLog;
+            return;
+        }
     }
 
-    inline ScopedConn::~ScopedConn() { 
+    inline ScopedConn::~ScopedConn() {
         // conLock releases...
     }
 
-    /*inline DBClientConnection* ScopedConn::operator->() { 
-        return &x->cc; 
+    /*inline DBClientConnection* ScopedConn::operator->() {
+        return &x->cc;
     }*/
 
 }