CXX-2 Implement support for connecting via mondodb:// URLs

acmorrow · acmorrow · commit 82bca967c8ca · 2014-07-03T16:08:31.000-04:00
diff --git a/.travis.yml b/.travis.yml
@@ -50,6 +50,7 @@ install:
       libboost-program-options1.49-dev
       libboost-filesystem1.49-dev
       libboost-thread1.49-dev
+      libboost-regex1.49-dev
 
     # Install MongoDB Enterprise and let smoke drive
     - sudo apt-get install mongodb-enterprise-server
diff --git a/SConstruct b/SConstruct
@@ -262,7 +262,7 @@ def printLocalInfo():
 
 printLocalInfo()
 
-boostLibs = [ "thread" , "system" ]
+boostLibs = [ "regex", "thread" , "system" ]
 
 linux64  = False
 force32 = has_option( "force32" ) 
diff --git a/src/mongo/SConscript b/src/mongo/SConscript
@@ -40,6 +40,7 @@ unittests = [
     'bson/bson_validate_test',
     'bson/bsonobjbuilder_test',
     'bson/util/bson_extract_test',
+    'client/connection_string_test',
     'client/dbclient_rs_test',
     'client/index_spec_test',
     'client/replica_set_monitor_test',
diff --git a/src/mongo/client/connection_string_test.cpp b/src/mongo/client/connection_string_test.cpp
@@ -0,0 +1,137 @@
+/*    Copyright 2014 MongoDB 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.
+ */
+
+#include "mongo/unittest/unittest.h"
+
+#include "mongo/client/dbclientinterface.h"
+
+namespace {
+    using mongo::ConnectionString;
+
+    struct URLTestCase {
+        std::string URL;
+        std::string uname;
+        std::string password;
+        mongo::ConnectionString::ConnectionType type;
+        std::string setname;
+        size_t numservers;
+        size_t numOptions;
+        std::string database;
+    };
+
+    const mongo::ConnectionString::ConnectionType kMaster = mongo::ConnectionString::MASTER;
+    const mongo::ConnectionString::ConnectionType kSet = mongo::ConnectionString::SET;
+
+    const URLTestCase cases[] = {
+
+        { "mongodb://user:pwd@127.0.0.1", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@127.0.0.1", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://127.0.0.1/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@127.0.0.1:1234", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@127.0.0.1:1234", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://127.0.0.1:1234/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@127.0.0.1,127.0.0.2/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@127.0.0.1,127.0.0.2/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://127.0.0.1,127.0.0.2/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName" },
+
+        { "mongodb://user:pwd@127.0.0.1:1234,127.0.0.2:1234/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@127.0.0.1:1234,127.0.0.2:1234/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://127.0.0.1:1234,127.0.0.1:1234/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName" },
+
+        { "mongodb://user:pwd@[::1]", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@[::1]", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://[::1]/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@[::1]:1234", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@[::1]:1234", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://[::1]:1234/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@[::1],127.0.0.2/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@[::1],127.0.0.2/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://[::1],127.0.0.2/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName" },
+
+        { "mongodb://user:pwd@[::1]:1234,127.0.0.2:1234/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@[::1]:1234,127.0.0.2:1234/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://[::1]:1234,[::1]:1234/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName" },
+
+        { "mongodb://user:pwd@[::1]", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@[::1]", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://[::1]/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@[::1]:1234", "user", "pwd", kMaster, "", 1, 0, "" },
+
+        { "mongodb://user@[::1]:1234", "user", "", kMaster, "", 1, 0, "" },
+
+        { "mongodb://[::1]:1234/dbName?foo=a&c=b", "", "", kMaster, "", 1, 2, "dbName" },
+
+        { "mongodb://user:pwd@[::1],127.0.0.2/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@[::1],127.0.0.2/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://[::1],127.0.0.2/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName" },
+
+        { "mongodb://user:pwd@[::1]:1234,127.0.0.2:1234/?replicaSet=replName", "user", "pwd", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://user@[::1]:1234,127.0.0.2:1234/?replicaSet=replName", "user", "", kSet, "replName", 2, 1, "" },
+
+        { "mongodb://[::1]:1234,[::1]:1234/dbName?foo=a&c=b&replicaSet=replName", "", "", kSet, "replName", 2, 3, "dbName"},
+    };
+
+
+    TEST(ConnectionString, GoodTrickyURLs) {
+
+        const size_t numCases = sizeof(cases) / sizeof(cases[0]);
+
+        for (size_t i = 0; i != numCases; ++i) {
+            const URLTestCase testCase = cases[i];
+            std::cout << "Testing URL: " << testCase.URL << '\n';
+            std::string errMsg;
+            const ConnectionString result = ConnectionString::parse(testCase.URL, errMsg);
+            ASSERT_TRUE(result.isValid());
+            ASSERT_TRUE(errMsg.empty());
+            ASSERT_EQ(testCase.uname, result.getUser());
+            ASSERT_EQ(testCase.password, result.getPassword());
+            ASSERT_EQ(testCase.type, result.type());
+            ASSERT_EQ(testCase.setname, result.getSetName());
+            ASSERT_EQ(testCase.numservers, result.getServers().size());
+            BSONObj options = result.getOptions();
+            std::set<std::string> fieldNames;
+            options.getFieldNames(fieldNames);
+            ASSERT_EQ(testCase.numOptions, fieldNames.size());
+            ASSERT_EQ(testCase.database, result.getDatabase());
+        }
+    }
+
+} // namespace
diff --git a/src/mongo/client/dbclient.cpp b/src/mongo/client/dbclient.cpp
@@ -41,6 +41,11 @@
 #include "mongo/util/net/ssl_manager.h"
 #include "mongo/util/password_digest.h"
 
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/regex.hpp>
+
 #include <algorithm>
 #include <cstdlib>
 
@@ -62,6 +67,26 @@ namespace mongo {
     const int defaultMaxMessageSizeBytes = defaultMaxBsonObjectSize * 2;
     const int defaultMaxWriteBatchSize = 1000;
 
+    namespace {
+        const char kMongoDBURL[] =
+            // scheme: non-capturing
+            "mongodb://"
+
+            // credentials: two inner captures for user and password
+            "(?:([^:]+)(?::([^@]+))?@)?"
+
+            // servers: grabs all host:port or UNIX socket names
+            "((?:(?:[^\\/]+|/.+.sock?),?)+)"
+
+            // database: matches anything but the chars that cannot
+            // be part of a MongoDB database name.
+            "(?:/([^/\\.\\ \"*<>:\\|\\?]*))?"
+
+            // options
+            "(?:\\?(?:(.+=.+)&?)+)*";
+
+    } // namespace
+
     void ConnectionString::_fillServers( string s ) {
         
         //
@@ -111,6 +136,30 @@ namespace mongo {
         _string = ss.str();
     }
 
+    BSONObj ConnectionString::_makeAuthObjFromOptions() const {
+        BSONObjBuilder bob;
+
+        // Add the username and optional password
+        invariant(!_user.empty());
+        bob.append("user", _user);
+        if (!_password.empty())
+            bob.append("pwd", _password);
+
+        BSONElement elt = _options.getField("authSource");
+        if (!elt.eoo())
+            bob.appendAs(elt, "db");
+
+        elt = _options.getField("authMechanism");
+        if (!elt.eoo())
+            bob.appendAs(elt, "mechanism");
+
+        elt = _options.getField("gssapiServiceName");
+        if (!elt.eoo())
+            bob.appendAs(elt, "serviceName");
+
+        return bob.obj();
+    }
+
     boost::mutex ConnectionString::_connectHookMutex;
     ConnectionString::ConnectionHook* ConnectionString::_connectHook = NULL;
 
@@ -125,6 +174,17 @@ namespace mongo {
                 delete c;
                 return 0;
             }
+
+            if (!_user.empty()) {
+                try {
+                    c->auth(_makeAuthObjFromOptions());
+                }
+                catch(...) {
+                    delete c;
+                    throw;
+                }
+            }
+
             LOG(1) << "connected connection!" << endl;
             return c;
         }
@@ -138,6 +198,17 @@ namespace mongo {
                 errmsg += toString();
                 return 0;
             }
+
+            if (!_user.empty()) {
+                try {
+                    set->auth(_makeAuthObjFromOptions());
+                }
+                catch(...) {
+                    delete set;
+                    throw;
+                }
+            }
+
             return set;
         }
 
@@ -192,26 +263,107 @@ namespace mongo {
         verify( false );
     }
 
-    ConnectionString ConnectionString::parse( const string& host , string& errmsg ) {
+    ConnectionString ConnectionString::parse( const string& url , string& errmsg ) {
 
-        string::size_type i = host.find( '/' );
+        if ( boost::algorithm::starts_with( url, "mongodb://" ) )
+            return _parseURL( url, errmsg );
+
+        string::size_type i = url.find( '/' );
         if ( i != string::npos && i != 0) {
             // replica set
-            return ConnectionString( SET , host.substr( i + 1 ) , host.substr( 0 , i ) );
+            return ConnectionString( SET , url.substr( i + 1 ) , url.substr( 0 , i ) );
         }
 
-        int numCommas = str::count( host , ',' );
+        int numCommas = str::count( url , ',' );
 
         if( numCommas == 0 )
-            return ConnectionString( HostAndPort( host ) );
+            return ConnectionString( HostAndPort( url ) );
 
         if ( numCommas == 1 )
-            return ConnectionString( PAIR , host );
+            return ConnectionString( PAIR , url );
 
-        errmsg = (string)"invalid hostname [" + host + "]";
+        errmsg = (string)"invalid hostname [" + url + "]";
         return ConnectionString(); // INVALID
     }
 
+    ConnectionString ConnectionString::_parseURL( const string& url, string& errmsg ) {
+
+        const boost::regex mongoUrlRe(kMongoDBURL);
+
+        boost::smatch matches;
+        if (!boost::regex_match(url, matches, mongoUrlRe)) {
+            errmsg = "Failed to parse mongodb:// URL: " + url;
+            return ConnectionString();
+        }
+
+        // We have 5 top level captures, plus the whole input.
+        invariant(matches.size() == 6);
+
+        if (!matches[3].matched) {
+            errmsg = "No server(s) specified";
+            return ConnectionString();
+        }
+
+        std::map<std::string, std::string> options;
+
+        if (matches[5].matched) {
+            const std::string optionsMatch = matches[5].str();
+
+            std::vector< boost::iterator_range<std::string::const_iterator> > optionsTokens;
+            boost::algorithm::split(
+                optionsTokens, optionsMatch, boost::algorithm::is_any_of("=&"));
+
+            invariant(optionsTokens.size() % 2 == 0);
+
+            for (size_t i = 0; i != optionsTokens.size(); i = i + 2)
+                options[std::string(optionsTokens[i].begin(), optionsTokens[i].end())] =
+                    std::string(optionsTokens[i + 1].begin(), optionsTokens[i + 1].end());
+        }
+
+        // Validate options against global driver state, and transform
+        // or append relevant options to the auth struct.
+
+        std::map<std::string, std::string>::const_iterator optIter;
+
+        // If a replica set option was specified, store it in the 'setName' field.
+        bool haveSetName;
+        std::string setName;
+        if ((haveSetName = ((optIter = options.find("replicaSet")) != options.end())))
+            setName = optIter->second;
+
+        // If an SSL option was specified that conflicts with the global setting, error out.
+        // The driver doesn't offer per connection settings.
+        if ((optIter = options.find("ssl")) != options.end()) {
+            if (optIter->second != (client::Options::current().SSLEnabled() ? "true" : "false")) {
+                errmsg = "Cannot override global driver SSL state in connection URL";
+                return ConnectionString();
+            }
+        }
+
+        // Add all remaining options into the bson object
+        BSONObjBuilder optionsBob;
+        for (optIter = options.begin(); optIter != options.end(); ++optIter)
+            optionsBob.append(optIter->first, optIter->second);
+
+        std::string servers = matches[3].str();
+        const bool direct = !haveSetName && (servers.find(',') == std::string::npos);
+
+        if (!direct && setName.empty()) {
+            errmsg = "Cannot list multiple servers in URL without 'replicaSet' option";
+            return ConnectionString();
+        }
+
+        return ConnectionString(
+            direct ? MASTER : SET,
+            matches[1].str(),
+            matches[2].str(),
+            servers,
+            matches[4].str(),
+            setName,
+            optionsBob.obj());
+
+    }
+
     string ConnectionString::typeToString( ConnectionType type ) {
         switch ( type ) {
         case INVALID:
diff --git a/src/mongo/client/dbclientinterface.h b/src/mongo/client/dbclientinterface.h
diff --git a/src/mongo/client/examples/rs.cpp b/src/mongo/client/examples/rs.cpp
