C++ pmdGetKRCB函数代码示例

   INT32 _pmdController::loadForeignModule()
   {
      INT32 rc = SDB_OK ;
      const CHAR *MONGO_MODULE_NAME = "fapmongo" ;
      const CHAR *MONGO_MODULE_PATH = "./bin/fap/" ;
      _fapMongo = SDB_OSS_NEW pmdModuleLoader() ;
      if ( NULL == _fapMongo )
      {
         PD_LOG( PDERROR, "Failed to alloc foreign access protocol module" ) ;
         rc = SDB_OOM ;
         goto error ;
      }
      rc = _fapMongo->load( MONGO_MODULE_NAME, MONGO_MODULE_PATH ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to load module: %s, path: %s"
                   " rc: %d", MONGO_MODULE_NAME, MONGO_MODULE_PATH, rc ) ;
      rc = _fapMongo->create( _protocol ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to create protocol service" ) ;
      rc = _protocol->init( pmdGetKRCB() ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to init protocol" ) ;

   done:
      return rc ;
   error:
      goto done ;
   }

   INT32 rtnCoord2PhaseCommit::doPhase2( CHAR * pReceiveBuffer, SINT32 packSize,
                                         CHAR * * ppResultBuffer, pmdEDUCB * cb,
                                         MsgOpReply & replyHeader )
   {
      INT32 rc = SDB_OK;
      pmdKRCB *pKrcb                   = pmdGetKRCB();
      CoordCB *pCoordcb                = pKrcb->getCoordCB();
      netMultiRouteAgent *pRouteAgent  = pCoordcb->getRouteAgent();
      CHAR *pMsgReq                    = NULL;
      MsgHeader *pMsgHead              = NULL;
      CoordGroupList groupLst;
      CoordGroupList sendGroupLst;

      rc = buildPhase2Msg( pReceiveBuffer, &pMsgReq );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to build the message on phase1(rc=%d)",
                  rc );

      pMsgHead = (MsgHeader *)pMsgReq;
      pMsgHead->TID = cb->getTID();

      rc = executeOnDataGroup( pMsgReq, pRouteAgent, cb );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to execute on data-group on phase1(rc=%d)",
                  rc );
   done:
      if ( pMsgReq )
      {
         SDB_OSS_FREE( pMsgReq );
         pMsgReq = NULL;
      }
      return rc;
   error:
      goto done;
   }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__SDB_DMSCB_DISPATCHPAGECLEANSU, "_SDB_DMSCB::dispatchPageCleanSU" )
   _dmsStorageUnit *_SDB_DMSCB::dispatchPageCleanSU ( dmsStorageUnitID *suID )
   {
      PD_TRACE_ENTRY ( SDB__SDB_DMSCB_DISPATCHPAGECLEANSU ) ;
      *suID               = DMS_INVALID_SUID ;
      pmdOptionsCB *optCB = pmdGetOptionCB() ;
      _dmsStorageUnit *su = NULL ;
      SDB_ASSERT ( suID, "suID can't be NULL" ) ;
      _pageCleanHistory firstSU ;
      ossTickDelta deltaTime ;

      ossScopedLock _lock(&_mutex, EXCLUSIVE) ;

      if ( _pageCleanHistoryList.size() == 0 )
         goto done ;
      firstSU = _pageCleanHistoryList.front() ;
      deltaTime = pmdGetKRCB()->getCurTime () - firstSU.first ;
      if ( deltaTime.toUINT64() / 1000 >
           (UINT64)optCB->getPageCleanInterval() )
      {
         PD_TRACE1 ( SDB__SDB_DMSCB_DISPATCHPAGECLEANSU,
                     PD_PACK_ULONG ( firstSU.second ) ) ;
         if ( NULL != _cscbVec[firstSU.second] )
         {
            *suID = firstSU.second ;
            _latchVec[*suID]->lock_r() ;
            su = _cscbVec[*suID]->_su ;
         }
         _pageCleanHistorySet.erase ( firstSU.second ) ;
         _pageCleanHistoryList.pop_front () ;
      }
   done :
      PD_TRACE_EXIT ( SDB__SDB_DMSCB_DISPATCHPAGECLEANSU ) ;
      return su ;
   }

   INT32 _rtnCoordSql::execute( MsgHeader *pMsg,
                                pmdEDUCB *cb,
                                INT64 &contextID,
                                rtnContextBuf *buf )

   {
      INT32 rc          = SDB_OK ;
      SQL_CB *sqlcb     = pmdGetKRCB()->getSqlCB() ;
      CHAR *sql         = NULL ;

      contextID         = -1 ;

      rc = msgExtractSql( (CHAR*)pMsg, &sql ) ;
      if ( SDB_OK != rc )
      {
         PD_LOG( PDERROR, "failed to extract sql" ) ;
         rc = SDB_SYS ;
         goto error ;
      }

      // add last op info
      MON_SAVE_OP_DETAIL( cb->getMonAppCB(), pMsg->opCode,
                          "%s", sql ) ;

      rc = sqlcb->exec( sql, cb, contextID ) ;

   done:
      return rc ;
   error:
      goto done ;
   }

   INT32 _pmdController::activeForeignModule()
   {
      INT32 rc = SDB_OK ;
      pmdEDUParam *pProtocolData = NULL ;
      pmdEDUMgr *pEDUMgr = pmdGetKRCB()->getEDUMgr() ;
      EDUID eduID = PMD_INVALID_EDUID ;

      if ( NULL == _fapMongo )
      {
         goto done ;
      }

      // listener for access protocol
      pProtocolData = new pmdEDUParam() ;
      pProtocolData->pSocket = (void *)_pMongoListener ;
      pProtocolData->protocol = _protocol ;
      rc = pEDUMgr->startEDU( EDU_TYPE_FAPLISTENER, (void*)pProtocolData,
                              &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start FAP listerner, rc: %d",
                   rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_FAPLISTENER, eduID ) ;

      // wait until protocol listener starts
      rc = pEDUMgr->waitUntil ( eduID, PMD_EDU_RUNNING ) ;
      PD_RC_CHECK( rc, PDERROR, "Wait FAP Listener active failed, rc: %d",
                   rc ) ;

   done:
      return rc ;
   error:
      goto done ;
   }

 INT32 rtnCoordTransCommit::execute( CHAR * pReceiveBuffer, SINT32 packSize,
                                  CHAR * * ppResultBuffer, pmdEDUCB * cb,
                                  MsgOpReply & replyHeader,
                                  BSONObj **ppErrorObj )
 {
    INT32 rc = SDB_OK;
    rtnCoordOperator *pRollbackOperator = NULL;
    rc = rtnCoord2PhaseCommit::execute( pReceiveBuffer, packSize, ppResultBuffer,
                                     cb, replyHeader, ppErrorObj );
    SDB_ASSERT( NULL == *ppErrorObj, "impossible" ) ;
    PD_RC_CHECK( rc, PDERROR,
                "failed to commit the transaction(rc=%d)",
                rc );
    cb->delTransaction();
 done:
    return rc;
 error:
    pRollbackOperator = pmdGetKRCB()->getCoordCB()->getProcesserFactory(
       )->getOperator( MSG_BS_TRANS_ROLLBACK_REQ );
    if ( pRollbackOperator )
    {
       pRollbackOperator->execute( pReceiveBuffer, packSize, ppResultBuffer,
                                  cb, replyHeader, ppErrorObj );
       SDB_ASSERT( NULL == *ppErrorObj, "impossible" ) ;
    }
    goto done;
 }

   INT32 _coordOmOperatorBase::queryOnOmAndPushToVec( const rtnQueryOptions &options,
                                                      pmdEDUCB *cb,
                                                      vector< BSONObj > &objs,
                                                      rtnContextBuf *buf )
   {
      INT32 rc = SDB_OK ;
      SINT64 contextID = -1 ;
      rtnContextBuf bufObj ;
      SDB_RTNCB *rtnCB = pmdGetKRCB()->getRTNCB() ;

      rc = queryOnOm( options, cb, contextID, buf ) ;
      if ( SDB_OK != rc )
      {
         PD_LOG( PDERROR, "Failed to query on om: %d", rc ) ;
         goto error ;
      }

      do
      {
         rc = rtnGetMore( contextID, -1, bufObj, cb, rtnCB ) ;
         if ( SDB_DMS_EOC == rc )
         {
            rc = SDB_OK ;
            contextID = -1 ;
            break ;
         }
         else if ( SDB_OK != rc )
         {
            contextID = -1 ;
            PD_LOG( PDERROR, "Failed to getmore from context, rc: %d", rc ) ;
            goto error ;
         }
         else
         {
            while ( !bufObj.eof() )
            {
               BSONObj obj ;
               rc = bufObj.nextObj( obj ) ;
               if ( SDB_OK != rc )
               {
                  PD_LOG( PDERROR, "Failed to get obj from obj buf, rc: %d",
                          rc ) ;
                  goto error ;
               }

               objs.push_back( obj.getOwned() ) ;
            }
         }
      } while( TRUE ) ;

   done:
      if ( -1 != contextID )
      {
         rtnCB->contextDelete( contextID, cb ) ;
      }
      return rc ;
   error:
      goto done ;
   }

 void _monAppCB::startOperator()
 {
    _lastOpBeginTime = pmdGetKRCB()->getCurTime() ;
    _lastOpEndTime.clear() ;
    _lastOpType = MSG_NULL ;
    _cmdType = CMD_UNKNOW ;
    ossMemset( _lastOpDetail, 0, sizeof(_lastOpDetail) ) ;
 }

   // PD_TRACE_DECLARE_FUNCTION( SDB__QGMPLDELETE__EXEC, "_qgmPlDelete::_execute" )
   INT32 _qgmPlDelete::_execute( _pmdEDUCB *eduCB )
   {
      PD_TRACE_ENTRY( SDB__QGMPLDELETE__EXEC ) ;
      INT32 rc = SDB_OK ;

      _SDB_KRCB *krcb = pmdGetKRCB() ;
      SDB_ROLE role = krcb->getDBRole() ;
      CHAR *msg = NULL ;
      if ( SDB_ROLE_COORD == role )
      {
         INT32 bufSize = 0 ;
         MsgOpReply dummyReply ;
         rtnCoordDelete del ;
         rc = msgBuildDeleteMsg( &msg, &bufSize,
                                 _collection.toString().c_str(),
                                 0, 0,
                                 _condition.isEmpty()?
                                 NULL : &_condition ) ;
         if ( SDB_OK != rc )
         {
            goto error ;
         }

         rc = del.execute( msg, *((SINT32 *)msg),
                           eduCB, dummyReply,
                           NULL ) ;
      }
      else
      {
         SDB_DPSCB *dpsCB = krcb->getDPSCB() ;

         if ( dpsCB && eduCB->isFromLocal() && !dpsCB->isLogLocal() )
         {
            dpsCB = NULL ;
         }
         SDB_DMSCB *dmsCB = krcb->getDMSCB() ;
         BSONObj empty ;
         rc = rtnDelete( _collection.toString().c_str(),
                         _condition, empty, 0, eduCB,
                         dmsCB, dpsCB ) ;
      }

      if ( SDB_OK != rc )
      {
         goto error ;
      }
   done:
      if ( NULL != msg )
      {
         SDB_OSS_FREE( msg ) ;
         msg = NULL ;
      }
      PD_TRACE_EXITRC( SDB__QGMPLDELETE__EXEC, rc ) ;
      return rc ;
   error:
      goto done ;
   }

 void _qgmPlCommand::_killContext()
 {
    if ( -1 != _contextID )
    {
       SDB_RTNCB *rtnCB = pmdGetKRCB()->getRTNCB() ;
       rtnKillContexts( 1, &_contextID, _eduCB, rtnCB ) ;
       _contextID = -1 ;
    }
    return ;
 }

 void _pmdCoordProcessor::_onDetach()
 {
    pmdDataProcessor::_onDetach() ;
    _CoordCB *pCoordCB = pmdGetKRCB()->getCoordCB() ;
    if ( eduCB() && pCoordCB )
    {
       netMultiRouteAgent *pRouteAgent = pCoordCB->getRouteAgent() ;
       pRouteAgent->delSession( eduCB()->getTID() ) ;
    }
 }

   // PD_TRACE_DECLARE_FUNCTION ( SDB__CLSREPSET_INIT, "_clsReplicateSet::initialize" )
   INT32 _clsReplicateSet::initialize ()
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__CLSREPSET_INIT ) ;

      if ( !_agent )
      {
         rc = SDB_INVALIDARG ;
         goto error ;
      }

      g_startShiftTime = (INT32)pmdGetOptionCB()->startShiftTime() ;

      _logger = pmdGetKRCB()->getDPSCB() ;
      _clsCB = pmdGetKRCB()->getClsCB() ;
      SDB_ASSERT( NULL != _logger, "logger should not be NULL" ) ;

      _logger->regEventHandler( this ) ;

      rc = _replBucket.init() ;
      PD_RC_CHECK( rc, PDERROR, "Init repl bucket failed, rc: %d", rc ) ;

      _totalLogSize = (UINT64)pmdGetOptionCB()->getReplLogFileSz()*
                      (UINT64)pmdGetOptionCB()->getReplLogFileNum() ;
      {
         UINT32 rate = 2 ;
         UINT32 timeBase = CLS_SYNCCTRL_BASE_TIME ;

         for ( UINT32 idx = 0 ; idx < CLS_SYNCCTRL_THRESHOLD_SIZE ; ++idx )
         {
            rate = 2 << idx ;
            _sizethreshold[ idx ] = _totalLogSize * ( rate - 1 ) / rate ;
            _timeThreshold[ idx ] = timeBase << idx ;
         }
      }

   done:
      PD_TRACE_EXITRC ( SDB__CLSREPSET_INIT, rc );
      return rc ;
   error:
      goto done ;
   }

   INT32 _CoordCB::init ()
   {
      INT32 rc = SDB_OK ;
      CoordGroupInfo *pGroupInfo = NULL ;
      UINT32 catGID = CATALOG_GROUPID ;
      UINT16 catNID = SYS_NODE_ID_BEGIN + CLS_REPLSET_MAX_NODE_SIZE ;
      MsgRouteID id ;
      pmdOptionsCB *optCB = pmdGetOptionCB() ;
      vector< _pmdAddrPair > catAddrs = optCB->catAddrs() ;

      _pNetWork = SDB_OSS_NEW _netRouteAgent( &_multiRouteAgent ) ;
      if ( !_pNetWork )
      {
         PD_LOG( PDERROR, "Failed to alloc memory for net agent" ) ;
         rc = SDB_OOM ;
         goto error ;
      }
      _multiRouteAgent.setNetWork( _pNetWork ) ;

      pGroupInfo = SDB_OSS_NEW CoordGroupInfo( CAT_CATALOG_GROUPID ) ;
      if ( !pGroupInfo )
      {
         PD_LOG( PDERROR, "Failed to alloc memory for group info" ) ;
         rc = SDB_OOM ;
         goto error ;
      }
      _catGroupInfo = CoordGroupInfoPtr( pGroupInfo ) ;

      for ( UINT32 i = 0 ; i < catAddrs.size() ; ++i )
      {
         if ( 0 == catAddrs[i]._host[ 0 ] )
         {
            break ;
         }
         id.columns.groupID = catGID ;
         id.columns.nodeID = catNID++ ;
         id.columns.serviceID = MSG_ROUTE_CAT_SERVICE ;
         addCatNodeAddr( id, catAddrs[i]._host, catAddrs[i]._service ) ;
      }

      pmdGetStartup().ok( TRUE ) ;
      pmdGetKRCB()->setGroupName( COORD_GROUPNAME ) ;
      {
         MsgRouteID id ;
         id.value = MSG_INVALID_ROUTEID ;
         id.columns.groupID = COORD_GROUPID ;
         pmdSetNodeID( id ) ;
      }

   done:
      return rc ;
   error:
      goto done ;
   }

 void _pmdEDUCB::clearTransInfo()
 {
    _curTransID = DPS_INVALID_TRANS_ID ;
    _relatedTransLSN = DPS_INVALID_LSN_OFFSET ;
    _curTransLSN = DPS_INVALID_LSN_OFFSET ;
    dpsTransCB *pTransCB = pmdGetKRCB()->getTransCB();
    if ( pTransCB )
    {
       pTransCB->transLockReleaseAll( this );
    }
 }

 // PD_TRACE_DECLARE_FUNCTION ( SDB__CLSCATCLR_HNDTMOUT, "_clsCatalogCaller::handleTimeout" )
 void _clsCatalogCaller::handleTimeout( const UINT32 &millisec )
 {
    PD_TRACE_ENTRY ( SDB__CLSCATCLR_HNDTMOUT );
    callerMeta::iterator itr = _meta.begin() ;
    for ( ; itr != _meta.end(); itr++ )
    {
       if ( CLS_CALLER_NO_SEND != itr->second.timeout )
       {
          itr->second.timeout += millisec ;
          if ( CLS_CALLER_INTERVAL <= itr->second.timeout )
          {
             pmdGetKRCB()->getClsCB()->updateCatGroup ( TRUE ) ;
             pmdGetKRCB()->getClsCB()->sendToCatlog( itr->second.header) ;
             itr->second.timeout = 0 ;
          }
       }
    }
    PD_TRACE_EXIT ( SDB__CLSCATCLR_HNDTMOUT );
    return ;
 }