MongoDB源碼分析--Command體系架構

作者：代震軍 2011-04-29 13:40:37

本文是用一篇專門介紹MongoDB中Command的體系架構的文章，并用例子來介紹mongod是如何將Command引入其中的。

Command在Mongodb中是一類特殊操作，它提供了強大的管理及各項操作（比如建庫，索引，刪除集合等）。可以說通過Command可以完成幾乎所有想做的事情。同時Mongodb開發者在Command上又做了非常清晰體系架構和設計，便于管理和高效執行各種類型的Command。

今天就專門用一篇篇幅來著重介紹一下其Command的體系架構，并用例子來介紹mongod是如何將Command引入其中的。

為了對其中大部分command對一個大致的了解，我們可以用下面指令來顯示一個command列表：

mongod --dbpath d:\mongodb\db --port 27017 --rest
在瀏覽器上輸入鏈接地址：http://localhost:28017/_commands

這里mongod就會為我們顯示command列表，大約有90多個，這是顯示截圖：

上面90多個類中，按其使用場景可以為分如下幾類，分別是：

dbcommand.cpp：一般數據庫指令，如數據庫，索引的創建，重建，打開/關閉等
dbcommands_admin.cpp：管理指令，如CleanCmd，JournalLatencyTestCmd，ValidateCmd，FSyncCommand
dbcommands_generic.cpp：常用指令,ListCommandsCmd,LogRotateCmd,PingCommand,CmdSet,CmdGet等
replset_commands.cpp：復制集指令，CmdReplSetTest，CmdReplSetGetStatus,CmdReplSetReconfig等
security_commands.cpp：安全指令,CmdGetNonce,CmdLogout,CmdAuthenticate

commands_admin.cpp：shard管理操作，因其位于mongos項目，這里暫不介紹
commands_public.cpp：shard公用操作，因其位于mongos項目，這里暫不介紹

下面是相關類圖：

-----------------------------分割線--------------------------------

#p#

首先我們看一下在Command的基類，其用于定義子類要實現的方法及屬性，自身也實現了一些通用方法，比如htmlHelp(用于以html方法顯示該command的幫助信息),構造方法，findCommand(查詢命令)等，其聲明如下：

//commands.h  
class Command {  
public:  
   //執行當前Command時所使用的鎖類型  
   enum LockType { READ = -1/*讀*/ , NONE = 0 /*無鎖*/, WRITE = 1 /*寫*/};  
 
   const string name;  
 
   /* 運行指定的命令，需要子類實現  
   fromRepl - command is being invoked as part of replication syncing.  In this situation you  
   normally do not want to log the command to the local oplog.  
 
   如執行成功返回true,否則為false, errmsg記錄錯誤信息  
   */ 
   virtual bool run(const string& db, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool fromRepl) = 0;  
 
   /*  
   note: logTheTop() MUST be false if READ  
   if NONE, can't use Client::Context setup  
   use with caution  
   */ 
   virtual LockType locktype() const = 0;  
 
   /* 是否有管理特權才可運行該命令 has privileges to run this command. */ 
   virtual bool adminOnly() const {  
      return false;  
   }  
   //html格式的幫助信息  
   void htmlHelp(stringstream&) const;  
 
   /* 與adminOnly相似,但更嚴格: 要么被驗證，要么只運行在本地接口（local interface）  
   注：當本屬性為true時，adminOnly()也必須為true.  
   */ 
   virtual bool localHostOnlyIfNoAuth(const BSONObj& cmdObj) { return false; }  
 
   /* 如果replication pair 的slaves可以運行命令的，則返回true  
   (the command directly from a client -- if fromRepl, always allowed).  
   */ 
   virtual bool slaveOk() const = 0;  
 
   /* 通過在查詢命令中打開 'slaveok'選項，客戶端強制在一個slave上運行一個命令時，返回true.  
   */ 
   virtual bool slaveOverrideOk() {  
      return false;  
   }  
 
   /* Override and return true to if true,log the operation (logOp()) to the replication log.  
   (not done if fromRepl of course)  
 
   Note if run() returns false, we do NOT log.  
   */ 
   virtual bool logTheOp() { return false; }  
 
   virtual void help( stringstream& help ) const;  
 
   /* Return true if authentication and security applies to the commands.  Some commands  
   (e.g., getnonce, authenticate) can be done by anyone even unauthorized.  
   */ 
   virtual bool requiresAuth() { return true; }  
 
   /** @param webUI：在web上暴露當前command，形如 localhost:28017/<name>  
   @param oldName： 舊選項，表示當前command的舊(已棄用)名稱  
   */ 
   Command(const char *_name, bool webUI = false, const char *oldName = 0);  
 
   virtual ~Command() {}  
 
protected:  
   BSONObj getQuery( const BSONObj& cmdObj ) {  
     if ( cmdObj["query"].type() == Object )  
        return cmdObj["query"].embeddedObject();  
     if ( cmdObj["q"].type() == Object )  
        return cmdObj["q"].embeddedObject();  
     return BSONObj();  
   }  
 
   static void logIfSlow( const Timer& cmdTimer,  const string& msg);  
   //command map,其包含系統實現的所有command對象，以便findCommand查詢時使用  
   //注意也包含該command的舊名稱（構造方法中的oldName參數）所對應的對象，  
   static map<string,Command*> * _commands;  
   //與上面形同，但不含舊名稱的command map  
   static map<string,Command*> * _commandsByBestName;  
   //將web類型的command放到該map中  
   static map<string,Command*> * _webCommands;  
 
public:  
   static const map<string,Command*>* commandsByBestName() { return _commandsByBestName; }  
   static const map<string,Command*>* webCommands() { return _webCommands; }  
   /** @return 返回是否找到或已執行command */ 
   static bool runAgainstRegistered(const char *ns, BSONObj& jsobj, BSONObjBuilder& anObjBuilder);  
   static LockType locktype( const string& name );  
   //根據命令名稱在集合中找到相應Command對象  
   static Command * findCommand( const string& name );  
};

Command基類中提供了幾個map<string,Command*>類型的集合map，用于將系統實現的Command進行收集，以便后面findCommand進行便歷查詢時使用。如下：

//commands.cpp  
Command* Command::findCommand( const string& name ) {  
   //從_commands map中找到指定name的Command對象  
   map<string,Command*>::iterator i = _commands->find( name );  
   if ( i == _commands->end() )//如果已到結尾，表示未找到  
      return 0;  
   return i->second;//返回Command對象  
}

看到上面代碼中的_commands大家可能要問，該map是如何初始化并將系統實現的各個Command注冊到其中呢？答案就在Command的構造方法中，如下：

//command.cpp  
Command::Command(const char *_name, bool web, const char *oldName) : name(_name) {  
   // register ourself.  
   //如為空（系統剛啟動時）則實例化_commands  
   if ( _commands == 0 )  
      _commands = new map<string,Command*>;  
   //如為空（系統剛啟動時）則實例化_commandsByBestName  
   if( _commandsByBestName == 0 )  
      _commandsByBestName = new map<string,Command*>;  
   Command*& c = (*_commands)[name];//獲取指定名稱的command對象  
   if ( c )//如有，表示之前已注冊了該command  
      log() << "warning: 2 commands with name: " << _name << endl;  
   //將當前command（this）賦值到map中相應name的command上  
   c = this;  
   //綁定到_commandsByBestName中的相應name上  
   (*_commandsByBestName)[name] = this;  
   //如果命令支持web方式  
   if( web ) {  
      //如為空（系統剛啟動時）則實例化_webCommands  
      if( _webCommands == 0 )  
         _webCommands = new map<string,Command*>;  
      //綁定到_webCommands中的相應name上  
      (*_webCommands)[name] = this;  
   }  
   //如有舊名稱，則也綁到_commands的oldName所指向的command  
   if( oldName )  
      (*_commands)[oldName] = this;  
}

有了這些還不夠，我們還要從90多個command子類中找出一個來實際分析其實現的方式，這里以最經常使用的count(獲取指定條件的記錄數)來分析其向map中注冊command的流程，參見下面代碼段：

//dbcommands.cpp  
/* select count(*) */ 
class CmdCount : public Command {  
public:  
   virtual LockType locktype() const { return READ; }  
   //調用基類的構造方法  
   CmdCount() : Command("count") { }  
 
   virtual bool logTheOp() {  
      return false;  
   }  
   virtual bool slaveOk() const {  
      // ok on --slave setups, not ok for nonmaster of a repl pair (unless override)  
      return replSettings.slave == SimpleSlave;  
   }  
   virtual bool slaveOverrideOk() {  
      return true;  
   }  
   virtual bool adminOnly() const {  
      return false;  
   }  
   virtual void help( stringstream& help ) const { help << "count objects in collection"; }  
   virtual bool run(const string& dbname, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool) {  
      string ns = dbname + '.' + cmdObj.firstElement().valuestr();  
      string err;  
      long long n = runCount(ns.c_str(), cmdObj, err);//執行查詢  
      long long nn = n;  
      bool ok = true;  
      if ( n == -1 ) {  
         nn = 0;  
         result.appendBool( "missing" , true );  
      }  
      else if ( n < 0 ) {  
         nn = 0;  
         ok = false;  
         if ( !err.empty() )  
            errmsg = err;  
      }  
      result.append("n", (double) nn);  
      return ok;  
   }  
}  cmdCount;

上面的CmdCount類即是在命令行模式下使用count指令時對應的代碼塊，其自身的構造函數就直接調用了基類(Command)的構造方法。但這里只是定義了還不夠，還需要一個定義類實例代碼（用于啟動構造函數），而這個任務就交給了該類定義的代碼結尾處的下面代碼來實現了：

} cmdCount;

可以看到，這里使用的是在類聲明后定義對象的方式來執行構造方法（這時并未使用new實例化方式來創建對象指針），進而注冊該command到map。當然繼承自Command的子類必須要實現其中的run()方法,因為只有它是具體command要執行的具體邏輯（可參見上面CmdCount的具體實現）。

到這里只能說mongod在系統啟動到實始化了相應的Command集合map信息，但mongod是如何將client發來的操作請求進行轉換并進而執行相應的command指令的呢？我們接下來繼續分析。

之前看過我的這篇文章的朋友可能還有印象，在mongod啟動之后，會循環偵聽指向端口上的用戶(client)請求，這些請求在mongod中被改裝成了message在各個功能類中傳遞。當用戶發送一個count指令操作時，其會在query.cpp中執行下面方法（以count查詢指令的執行流程為例來進行分析）：

//query.cpp  
const char *runQuery(Message& m, QueryMessage& q, CurOp& curop, Message &result) {  
   StringBuilder& ss = curop.debug().str;  
   //構造ParsedQuery查詢對象，該對象包括查詢記錄數字，以及記錄跳轉偏移量等信息，  
 
   //這些值會在訪問磁盤查詢時使用，用法參見:query.cpp 662行的virtual void _init()方法  
   shared_ptr<ParsedQuery> pq_shared( new ParsedQuery(q) );  
   ParsedQuery& pq( *pq_shared );  
   ......  
   //對查詢命令判斷，指令形如abc.$cmd.findOne( { ismaster:1 } )  
   if ( pq.couldBeCommand() ) {//_ns中包括$cmd字符串  
  BufBuilder bb;  
  bb.skip(sizeof(QueryResult));  
  BSONObjBuilder cmdResBuf;  
  //對查詢權限判斷，并執行相應查詢指令  
  if ( runCommands(ns, jsobj, curop, bb, cmdResBuf, false, queryOptions) ) {  
     ss << " command: ";  
     jsobj.toString( ss );  
     curop.markCommand();  
     auto_ptr< QueryResult > qr;  
     qr.reset( (QueryResult *) bb.buf() );  
     bb.decouple();  
     qr->setResultFlagsToOk();  
     qr->len = bb.len();  
     ss << " reslen:" << bb.len();  
     qr->setOperation(opReply);  
     qr->cursorId = 0;  
     qr->startingFrom = 0;  
     qr->nReturned = 1;  
     result.setData( qr.release(), true );//設置返回結果  
  }  
  else {  
     uasserted(13530, "bad or malformed command request?");  
  }  
  return 0;  
   }  
.....  
}

上面代碼對傳遞來的查詢消息QueryMessage進行分析之后，如果發現其為command時，執行runCommands方法：

//query.cpp     
bool runCommands(const char *ns, BSONObj& jsobj, CurOp& curop, BufBuilder &b, BSONObjBuilder& anObjBuilder, bool fromRepl, int queryOptions) {  
   try {  
      return _runCommands(ns, jsobj, b, anObjBuilder, fromRepl, queryOptions);  
   }  
   catch ( AssertionException& e ) {  
      e.getInfo().append( anObjBuilder , "assertion" , "assertionCode" );  
   }  
   curop.debug().str << " assertion ";  
   anObjBuilder.append("errmsg", "db assertion failure");  
   anObjBuilder.append("ok", 0.0);  
   BSONObj x = anObjBuilder.done();  
   b.appendBuf((void*) x.objdata(), x.objsize());  
   return true;  
}

接著其會執行dbcommands.cpp中的_runCommands()方法

//dbcommands.cpp  
  bool _runCommands(const char *ns, BSONObj& _cmdobj, BufBuilder &b, BSONObjBuilder& anObjBuilder, bool fromRepl, int queryOptions) {  
  cc().curop()->ensureStarted();  
  string dbname = nsToDatabase( ns );  
 
  if( logLevel >= 1 )  
     log() << "run command " << ns << ' ' << _cmdobj << endl;  
 
  const char *p = strchr(ns, '.');  
  if ( !p ) return false;  
  //再次進行cmd判斷，以確定是command  
  if ( strcmp(p, ".$cmd") != 0 ) return false;  
 
  BSONObj jsobj;  
  {  
     BSONElement e = _cmdobj.firstElement();  
     if ( e.type() == Object && string("query") == e.fieldName() ) {  
        jsobj = e.embeddedObject();  
     }  
     else {  
        jsobj = _cmdobj;  
     }  
  }  
 
  Client& client = cc();  
  bool ok = false;  
 
  BSONElement e = jsobj.firstElement();  
  //根據command名稱從map中找出相應的command對象  
  Command * c = e.type() ? Command::findCommand( e.fieldName() ) : 0;  
 
  if ( c ) {  
     //執行該對象  
     ok = execCommand( c , client , queryOptions , ns , jsobj , anObjBuilder , fromRepl );  
  }  
  else {  
     anObjBuilder.append("errmsg", str::stream() << "no such cmd: " << e.fieldName() );  
     anObjBuilder.append("bad cmd" , _cmdobj );  
  }  
 
  // switch to bool, but wait a bit longer before switching?  
  // anObjBuilder.append("ok", ok);  
  anObjBuilder.append("ok", ok?1.0:0.0);  
  BSONObj x = anObjBuilder.done();  
  b.appendBuf((void*) x.objdata(), x.objsize());  
 
  return true;

上面代碼主要是從map中找出相應的command對象，并將該對象及操作命令參數和client(用于獲取其中的認證信息，以確定其執行權限)作為參數，來調用 execCommand方法：

//dbcommands.cpp  
bool execCommand( Command * c ,  
  Client& client , int queryOptions ,  
  const char *cmdns, BSONObj& cmdObj ,  
  BSONObjBuilder& result /*返回command執行結果*/,  
  bool fromRepl ) {  
 
     string dbname = nsToDatabase( cmdns );  
 
     AuthenticationInfo *ai = client.getAuthenticationInfo();  
     
     if( c->adminOnly() /*如果需要有管理特權開可運行*/ 
     && c->localHostOnlyIfNoAuth( cmdObj ) /*要么被驗證，要么只運行在本地接口*/ 
     && noauth && !ai->isLocalHost ) {//未認證 且 不是在本地運行  
        result.append( "errmsg" ,  
        "unauthorized: this command must run from localhost when running db without auth" );  
        log() << "command denied: " << cmdObj.toString() << endl;  
        return false;  
     }  
 
    if ( c->adminOnly() && ! fromRepl && dbname != "admin" ) {  
       result.append( "errmsg" ,  "access denied; use admin db" );  
       log() << "command denied: " << cmdObj.toString() << endl;  
       return false;  
    }  
 
   if ( cmdObj["help"].trueValue() ) {  
      stringstream ss;  
      ss << "help for: " << c->name << " ";  
      c->help( ss );  
      result.append( "help" , ss.str() );  
      result.append( "lockType" , c->locktype() );  
      return true;  
   }  
 
   bool canRunHere =  
   isMaster( dbname.c_str() ) /*如為master庫*/||  
   c->slaveOk() /*如果replication pair 的slaves可以運行命令*/||  
   ( c->slaveOverrideOk() && ( queryOptions & QueryOption_SlaveOk ) ) ||  
   fromRepl;  
 
   if ( ! canRunHere ) {  
      result.append( "errmsg" , "not master" );  
      return false;  
   }  
 
   if ( c->adminOnly() )  
      log( 2 ) << "command: " << cmdObj << endl;  
 
   //如當前command無須鎖時  
   if ( c->locktype() == Command::NONE ) {  
      // we also trust that this won't crash  
      string errmsg;  
      //運行當前command  
      int ok = c->run( dbname , cmdObj , errmsg , result , fromRepl );  
      if ( ! ok )  
         result.append( "errmsg" , errmsg );  
      return ok;  
   }  
   //判斷執行當前command是否需要'寫鎖'(每個command子類都有該屬性)，枚舉定義如下(command.h)：  
   //enum LockType { READ = -1/*讀*/ , NONE = 0 /*無鎖*/, WRITE = 1 /*寫*/};  
   bool needWriteLock = c->locktype() == Command::WRITE;  
 
   if ( ! needWriteLock ) {  
      assert( ! c->logTheOp() );  
   }  
 
   mongolock lk( needWriteLock );//聲明鎖對象  
   Client::Context ctx( dbname , dbpath , &lk , c->requiresAuth() );  
 
   try {  
      string errmsg;  
      //運行當前command(本文中提到的count命令)  
      if ( ! c->run(dbname, cmdObj, errmsg, result, fromRepl ) ) {  
         result.append( "errmsg" , errmsg );  
         return false;  
      }  
   }  
   catch ( DBException& e ) {  
      stringstream ss;  
      ss << "exception: " << e.what();  
      result.append( "errmsg" , ss.str() );  
      result.append( "code" , e.getCode() );  
      return false;  
   }  
 
   if ( c->logTheOp() && ! fromRepl ) {  
      logOp("c", cmdns, cmdObj);  
   }  
 
   return true;  
}

到這里，流程基本就執行完畢了，之后它會將結果傳給result（其傳參為引用類型，即："& result"方式）.

#p#

***用一張時間序來大體回顧一下這***程：

好了，今天的內容到這里就告一段落了。

參考鏈接：
http://www.mongodb.org/display/DOCS/Commands
http://www.10gen.com/reference

原文鏈接:http://www.cnblogs.com/daizhj/archive/2011/04/29/mongos_command_source_code.html

【編輯推薦】

Mongodb源碼分析--內存文件映射(MMAP)
走進MongoDB的世界展開MongoDB的學習之旅
淺析Mongodb源碼之游標Cursor
野心勃勃的NoSQL新貴 MongoDB應用實戰
MongoDB與CouchDB全方位對比

責任編輯：艾婧來源：博客園

MongoDB Command