SERVER-13635: remove path concept from DatabaseHolder, and move repair and listDatabase into storageEngine

Author: erh

src/mongo/SConscript

@@ -559,6 +559,7 @@ serverOnlyFiles = [ "db/curop.cpp",
                     "db/storage/mmap_v1/dur_recovery_unit.cpp",
                     "db/storage/mmap_v1/mmap_v1_database_catalog_entry.cpp",
                     "db/storage/mmap_v1/mmap_v1_engine.cpp",
+                    "db/storage/mmap_v1/repair_database.cpp",
                     "db/operation_context_impl.cpp",
                     "db/storage/mmap_v1/mmap_v1_extent_manager.cpp",
                     "db/introspect.cpp",
@@ -627,7 +628,6 @@ serverOnlyFiles = [ "db/curop.cpp",
                     "db/catalog/database_holder.cpp",
                     "db/background.cpp",
                     "db/pdfile.cpp",
-                    "db/repair_database.cpp",
                     "db/structure/catalog/index_details.cpp",
                     "db/index_builder.cpp",
                     "db/index_rebuilder.cpp",

src/mongo/db/auth/authz_manager_external_state_d.cpp

@@ -40,6 +40,7 @@
 #include "mongo/db/instance.h"
 #include "mongo/db/jsobj.h"
 #include "mongo/db/operation_context_impl.h"
+#include "mongo/db/storage/storage_engine.h"
 #include "mongo/util/assert_util.h"
 #include "mongo/util/mongoutils/str.h"
 
@@ -99,8 +100,7 @@ namespace mongo {
 
     Status AuthzManagerExternalStateMongod::getAllDatabaseNames(
                 OperationContext* txn, std::vector<std::string>* dbnames) {
-        Lock::GlobalRead lk(txn->lockState());
-        getDatabaseNames(*dbnames);
+        globalStorageEngine->listDatabases( dbnames );
         return Status::OK();
     }
 

src/mongo/db/catalog/collection_cursor_cache.cpp

@@ -188,7 +188,7 @@ namespace mongo {
         }
 
         Lock::DBRead lock(txn->lockState(), ns);
-        Database* db = dbHolder().get(txn, ns, storageGlobalParams.dbpath);
+        Database* db = dbHolder().get(txn, ns);
         if ( !db )
             return false;
         Client::Context context( ns, db );
@@ -218,7 +218,7 @@ namespace mongo {
         for ( unsigned i = 0; i < todo.size(); i++ ) {
             const string& ns = todo[i];
             Lock::DBRead lock(txn->lockState(), ns);
-            Database* db = dbHolder().get(txn, ns, storageGlobalParams.dbpath);
+            Database* db = dbHolder().get(txn, ns);
             if ( !db )
                 continue;
             Client::Context context( ns, db );

src/mongo/db/catalog/database.cpp

@@ -50,6 +50,7 @@
 #include "mongo/db/pdfile.h"
 #include "mongo/db/server_parameters.h"
 #include "mongo/db/storage_options.h"
+#include "mongo/db/storage/storage_engine.h"
 #include "mongo/db/catalog/collection.h"
 
 namespace mongo {
@@ -124,13 +125,13 @@ namespace mongo {
 
 
     /*static*/
-    string Database::duplicateUncasedName(const string &name, const string &path, set< string > *duplicates) {
+    string Database::duplicateUncasedName(const string &name, set< string > *duplicates) {
         if ( duplicates ) {
             duplicates->clear();
         }
 
         vector<string> others;
-        getDatabaseNames( others , path );
+        globalStorageEngine->listDatabases( &others );
 
         set<string> allShortNames;
         dbHolder().getAllShortNames(allShortNames);

src/mongo/db/catalog/database.h

@@ -64,8 +64,11 @@ namespace mongo {
         /* you must use this to close - there is essential code in this method that is not in the ~Database destructor.
            thus the destructor is private.  this could be cleaned up one day...
         */
-        static void closeDatabase(
-                        OperationContext* txn, const std::string& db, const std::string& path);
+        static void closeDatabase(OperationContext* txn,
+                                  const std::string& db);
+
+        // do not use!
+        ~Database(); // closes files and other cleanup see below.
 
         const std::string& name() const { return _name; }
 
@@ -129,7 +132,6 @@ namespace mongo {
          // TODO move???
          */
         static string duplicateUncasedName( const std::string &name,
-                                            const std::string &path,
                                             std::set< std::string > *duplicates = 0 );
 
         static Status validateDBName( const StringData& dbname );
@@ -141,8 +143,6 @@ namespace mongo {
 
         void _clearCollectionCache_inlock( const StringData& fullns );
 
-        ~Database(); // closes files and other cleanup see below.
-
         const std::string _name; // "alleyinsider"
 
         boost::scoped_ptr<DatabaseCatalogEntry> _dbEntry;

src/mongo/db/catalog/database_holder.cpp

@@ -47,25 +47,21 @@
 namespace mongo {
 
     Database* DatabaseHolder::get(OperationContext* txn,
-                                  const std::string& ns,
-                                  const std::string& path) const {
+                                  const std::string& ns) const {
 
         txn->lockState()->assertAtLeastReadLocked(ns);
 
         SimpleMutex::scoped_lock lk(_m);
-        Paths::const_iterator x = _paths.find( path );
-        if ( x == _paths.end() )
-            return 0;
-        const DBs& m = x->second;
         const std::string db = _todb( ns );
-        DBs::const_iterator it = m.find(db);
-        if ( it != m.end() )
+        DBs::const_iterator it = _dbs.find(db);
+        if ( it != _dbs.end() )
             return it->second;
         return NULL;
     }
 
-    Database* DatabaseHolder::getOrCreate(
-                OperationContext* txn, const string& ns, const string& path, bool& justCreated) {
+    Database* DatabaseHolder::getOrCreate(OperationContext* txn,
+                                          const string& ns,
+                                          bool& justCreated) {
 
         const string dbname = _todb( ns );
         invariant(txn->lockState()->isAtLeastReadLocked(dbname));
@@ -76,10 +72,9 @@ namespace mongo {
 
         {
             SimpleMutex::scoped_lock lk(_m);
-            DBs& m = _paths[path];
             {
-                DBs::iterator i = m.find(dbname);
-                if( i != m.end() ) {
+                DBs::iterator i = _dbs.find(dbname);
+                if( i != _dbs.end() ) {
                     justCreated = false;
                     return i->second;
                 }
@@ -90,10 +85,8 @@ namespace mongo {
             //       perhaps just log it, which is what we do here with the "> 40" :
             bool cant = !txn->lockState()->isWriteLocked(ns);
             if( logger::globalLogDomain()->shouldLog(logger::LogSeverity::Debug(1)) ||
-                m.size() > 40 || cant || DEBUG_BUILD ) {
-                log() << "opening db: "
-                      << (path == storageGlobalParams.dbpath ? "" : path) << ' ' << dbname
-                      << endl;
+                _dbs.size() > 40 || cant || DEBUG_BUILD ) {
+                log() << "opening db: " << dbname;
             }
             massert(15927, "can't open database in a read lock. if db was just closed, consider retrying the query. might otherwise indicate an internal error", !cant);
         }
@@ -107,43 +100,36 @@ namespace mongo {
                                     dbname,
                                     justCreated,
                                     new MMAPV1DatabaseCatalogEntry(txn,
-                                                                  dbname,
-                                                                  path,
-                                                                  storageGlobalParams.directoryperdb));
+                                                                   dbname,
+                                                                   storageGlobalParams.dbpath,
+                                                                   storageGlobalParams.directoryperdb,
+                                                                   false));
 
         {
             SimpleMutex::scoped_lock lk(_m);
-            DBs& m = _paths[path];
-            verify( m[dbname] == 0 );
-            m[dbname] = db;
-            _size++;
+            _dbs[dbname] = db;
         }
 
         return db;
     }
 
     void DatabaseHolder::erase(OperationContext* txn,
-                               const std::string& ns,
-                               const std::string& path) {
+                               const std::string& ns) {
         invariant(txn->lockState()->isW());
 
         SimpleMutex::scoped_lock lk(_m);
-        DBs& m = _paths[path];
-        _size -= (int)m.erase(_todb(ns));
+        _dbs.erase(_todb(ns));
     }
 
-    bool DatabaseHolder::closeAll(
-                OperationContext* txn, const string& path, BSONObjBuilder& result, bool force) {
-        log() << "DatabaseHolder::closeAll path:" << path << endl;
+    bool DatabaseHolder::closeAll(OperationContext* txn,
+                                  BSONObjBuilder& result,
+                                  bool force) {
         invariant(txn->lockState()->isW());
 
         getDur().commitNow(txn); // bad things happen if we close a DB with outstanding writes
 
-        map<string,Database*>& m = _paths[path];
-        _size -= m.size();
-
         set< string > dbs;
-        for ( map<string,Database*>::iterator i = m.begin(); i != m.end(); i++ ) {
+        for ( map<string,Database*>::iterator i = _dbs.begin(); i != _dbs.end(); i++ ) {
             dbs.insert( i->first );
         }
 
@@ -152,8 +138,8 @@ namespace mongo {
         int nNotClosed = 0;
         for( set< string >::iterator i = dbs.begin(); i != dbs.end(); ++i ) {
             string name = *i;
-            LOG(2) << "DatabaseHolder::closeAll path:" << path << " name:" << name << endl;
-            Client::Context ctx( name , path );
+            LOG(2) << "DatabaseHolder::closeAll name:" << name;
+            Client::Context ctx( name );
             if( !force && BackgroundOperation::inProgForDb(name) ) {
                 log() << "WARNING: can't close database "
                       << name
@@ -162,7 +148,7 @@ namespace mongo {
                 nNotClosed++;
             }
             else {
-                Database::closeDatabase(txn, name.c_str(), path);
+                Database::closeDatabase(txn, name.c_str());
                 bb.append( bb.numStr( n++ ) , name );
             }
         }

src/mongo/db/catalog/database_holder.h

@@ -34,52 +34,40 @@
 #include "mongo/db/d_concurrency.h"
 #include "mongo/db/namespace_string.h"
 
-namespace mongo { 
+namespace mongo {
 
     /**
-     * path + dbname -> Database
+     * dbname -> Database
      */
     class DatabaseHolder {
         typedef std::map<std::string,Database*> DBs;
-        typedef std::map<std::string,DBs> Paths;
         // todo: we want something faster than this if called a lot:
         mutable SimpleMutex _m;
-        Paths _paths;
-        int _size;
+        DBs _dbs;
     public:
-        DatabaseHolder() : _m("dbholder"),_size(0) { }
+        DatabaseHolder() : _m("dbholder"){ }
 
         Database* get(OperationContext* txn,
-                      const std::string& ns,
-                      const std::string& path) const;
+                      const std::string& ns) const;
 
         Database* getOrCreate(OperationContext* txn,
                               const std::string& ns,
-                              const std::string& path,
                               bool& justCreated);
 
-        void erase(OperationContext* txn, const std::string& ns, const std::string& path);
+        void erase(OperationContext* txn, const std::string& ns);
 
         /** @param force - force close even if something underway - use at shutdown */
         bool closeAll(OperationContext* txn,
-                      const std::string& path,
                       BSONObjBuilder& result,
                       bool force);
 
-        // "info" as this is informational only could change on you if you are not write locked
-        int sizeInfo() const { return _size; }
-
         /**
-         * gets all unique db names, ignoring paths
          * need some lock
          */
         void getAllShortNames( std::set<std::string>& all ) const {
             SimpleMutex::scoped_lock lk(_m);
-            for ( Paths::const_iterator i=_paths.begin(); i!=_paths.end(); i++ ) {
-                DBs m = i->second;
-                for( DBs::const_iterator j=m.begin(); j!=m.end(); j++ ) {
-                    all.insert( j->first );
-                }
+            for( DBs::const_iterator j=_dbs.begin(); j!=_dbs.end(); j++ ) {
+                all.insert( j->first );
             }
         }
 

src/mongo/db/client.cpp

@@ -164,8 +164,6 @@ namespace mongo {
     BSONObj CachedBSONObjBase::_tooBig = fromjson("{\"$msg\":\"query not recording (too large)\"}");
     Client::Context::Context(const std::string& ns , Database * db) :
         _client( currentClient.get() ), 
-        _path(storageGlobalParams.dbpath), // is this right? could be a different db?
-                                               // may need a dassert for this
         _justCreated(false),
         _doVersion( true ),
         _ns( ns ), 
@@ -174,9 +172,8 @@ namespace mongo {
 
     }
 
-    Client::Context::Context(const string& ns, const std::string& path, bool doVersion) :
+    Client::Context::Context(const string& ns, bool doVersion) :
         _client( currentClient.get() ), 
-        _path( path ), 
         _justCreated(false), // set for real in finishInit
         _doVersion(doVersion),
         _ns( ns ), 
@@ -192,9 +189,9 @@ namespace mongo {
                 OperationContext* txn, const string& ns, bool doVersion) {
         {
             _lk.reset(new Lock::DBRead(txn->lockState(), ns));
-            Database *db = dbHolder().get(txn, ns, storageGlobalParams.dbpath);
+            Database *db = dbHolder().get(txn, ns);
             if( db ) {
-                _c.reset(new Context(storageGlobalParams.dbpath, ns, db, doVersion));
+                _c.reset(new Context(ns, db, doVersion));
                 return;
             }
         }
@@ -205,18 +202,18 @@ namespace mongo {
             if (txn->lockState()->isW()) {
                 // write locked already
                 DEV RARELY log() << "write locked on ReadContext construction " << ns << endl;
-                _c.reset(new Context(ns, storageGlobalParams.dbpath, doVersion));
+                _c.reset(new Context(ns, doVersion));
             }
             else if (!txn->lockState()->isRecursive()) {
                 _lk.reset(0);
                 {
                     Lock::GlobalWrite w(txn->lockState());
-                    Context c(ns, storageGlobalParams.dbpath, doVersion);
+                    Context c(ns, doVersion);
                 }
 
                 // db could be closed at this interim point -- that is ok, we will throw, and don't mind throwing.
                 _lk.reset(new Lock::DBRead(txn->lockState(), ns));
-                _c.reset(new Context(ns, storageGlobalParams.dbpath, doVersion));
+                _c.reset(new Context(ns, doVersion));
             }
             else { 
                 uasserted(15928, str::stream() << "can't open a database from a nested read lock " << ns);
@@ -231,7 +228,7 @@ namespace mongo {
     Client::WriteContext::WriteContext(
                 OperationContext* opCtx, const std::string& ns, bool doVersion)
         : _lk(opCtx->lockState(), ns),
-          _c(ns, storageGlobalParams.dbpath, doVersion) {
+          _c(ns, doVersion) {
     }
 
 
@@ -255,9 +252,8 @@ namespace mongo {
     }
 
     // invoked from ReadContext
-    Client::Context::Context(const string& path, const string& ns, Database *db, bool doVersion) :
+    Client::Context::Context(const string& ns, Database *db, bool doVersion) :
         _client( currentClient.get() ), 
-        _path( path ), 
         _justCreated(false),
         _doVersion( doVersion ),
         _ns( ns ), 
@@ -270,7 +266,7 @@ namespace mongo {
 
     void Client::Context::_finishInit() {
         OperationContextImpl txn; // TODO get rid of this once reads require transactions
-        _db = dbHolder().getOrCreate(&txn, _ns, _path, _justCreated);
+        _db = dbHolder().getOrCreate(&txn, _ns, _justCreated);
         invariant(_db);
 
         if( _doVersion ) checkNotStale();