Example #1
0
   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;
   }
Example #3
0
   // 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 ;
   }
Example #4
0
   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 ;
   }
Example #5
0
   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;
 }
Example #7
0
   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 ;
   }
Example #8
0
 void _monAppCB::startOperator()
 {
    _lastOpBeginTime = pmdGetKRCB()->getCurTime() ;
    _lastOpEndTime.clear() ;
    _lastOpType = MSG_NULL ;
    _cmdType = CMD_UNKNOW ;
    ossMemset( _lastOpDetail, 0, sizeof(_lastOpDetail) ) ;
 }
   INT32 rtnCoordTransRollback::execute( CHAR * pReceiveBuffer, SINT32 packSize,
                                         CHAR * * ppResultBuffer, pmdEDUCB * cb,
                                         MsgOpReply & replyHeader,
                                         BSONObj **ppErrorObj )
   {
      INT32 rc                         = SDB_OK;
      CHAR *pMsgReq                    = NULL;
      MsgHeader *pMsgHead              = NULL;
      INT32 bufferSize                 = 0;
      pmdKRCB *pKrcb                   = pmdGetKRCB();
      CoordCB *pCoordcb                = pKrcb->getCoordCB();
      netMultiRouteAgent *pRouteAgent  = pCoordcb->getRouteAgent();
      MsgHeader *pHeader               = (MsgHeader *)pReceiveBuffer;
      replyHeader.header.messageLength = sizeof( MsgOpReply );
      replyHeader.header.opCode        = MSG_BS_TRANS_ROLLBACK_RSP;
      replyHeader.header.routeID.value = 0;
      replyHeader.contextID            = -1;
      replyHeader.flags                = SDB_OK;
      replyHeader.numReturned          = 0;
      replyHeader.startFrom            = 0;

      if ( pHeader )
      {
         replyHeader.header.requestID     = pHeader->requestID;
         replyHeader.header.TID           = pHeader->TID;
      }

      if ( !cb->isTransaction() )
      {
         rc = SDB_DPS_TRANS_NO_TRANS;
         goto error;
      }

      cb->startRollback();

      rc = msgBuildTransRollbackMsg( &pMsgReq, &bufferSize );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to build the message(rc=%d)",
                  rc );

      pMsgHead = (MsgHeader *)pMsgReq;
      pMsgHead->TID = cb->getTID();
      rc = executeOnDataGroup( pMsgReq, pRouteAgent, cb );
      cb->delTransaction();
      PD_RC_CHECK( rc, PDERROR,
                  "failed to rollback(rc=%d)",
                  rc );
   done:
      if ( pMsgReq )
      {
         SDB_OSS_FREE( pMsgReq );
      }
      cb->stopRollback();
      return rc;
   error:
      replyHeader.flags = rc;
      goto done;
   }
Example #10
0
   // 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 ;
   }
Example #11
0
 void _monAppCB::endOperator()
 {
    if ( (BOOLEAN)_lastOpBeginTime )
    {
       _lastOpEndTime = pmdGetKRCB()->getCurTime() ;
       ossTickDelta delta = _lastOpEndTime - _lastOpBeginTime ;
       opTimeSpentInc( delta ) ;
    }
 }
Example #12
0
 void _qgmPlCommand::_killContext()
 {
    if ( -1 != _contextID )
    {
       SDB_RTNCB *rtnCB = pmdGetKRCB()->getRTNCB() ;
       rtnKillContexts( 1, &_contextID, _eduCB, rtnCB ) ;
       _contextID = -1 ;
    }
    return ;
 }
Example #13
0
 void _pmdCoordProcessor::_onDetach()
 {
    pmdDataProcessor::_onDetach() ;
    _CoordCB *pCoordCB = pmdGetKRCB()->getCoordCB() ;
    if ( eduCB() && pCoordCB )
    {
       netMultiRouteAgent *pRouteAgent = pCoordCB->getRouteAgent() ;
       pRouteAgent->delSession( eduCB()->getTID() ) ;
    }
 }
Example #14
0
   // 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 ;
   }
Example #15
0
   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 ;
   }
Example #16
0
 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 );
    }
 }
Example #17
0
 // 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 ;
 }
Example #18
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB_PMDBGJOBENTPNT, "pmdBackgroundJobEntryPoint" )
   INT32 pmdBackgroundJobEntryPoint( pmdEDUCB *cb, void *pData )
   {
      SDB_ASSERT( NULL != pData, "impossible" ) ;
      PD_TRACE_ENTRY ( SDB_PMDBGJOBENTPNT );
      rtnJobMgr *jobMgr = rtnGetJobMgr () ;
      pmdEDUMgr *pEDUMgr = pmdGetKRCB()->getEDUMgr() ;
      rtnBaseJob *job = (rtnBaseJob*)pData ;
      INT32 rc = SDB_OK ;
      BOOLEAN reuseEDU = job->reuseEDU() ;
      string expStr ;

      PD_LOG( PDINFO, "Start a background job[%s]", job->name() ) ;

      cb->setName( job->name() ) ;
      job->attachIn( cb ) ;

      try
      {
         pEDUMgr->activateEDU( cb ) ;
         rc = job->doit () ;
         if ( SDB_OK != rc )
         {
            PD_LOG ( PDWARNING, "Background job[%s] do failed, rc = %d",
                     job->name(), rc ) ;
         }
         else
         {
            PD_LOG ( PDINFO, "Background job[%s] finished", job->name() ) ;
         }
      }
      catch( std::exception &e )
      {
         PD_LOG( PDERROR, "Occur exception: %s", e.what() ) ;
         rc = SDB_SYS ;
         expStr = e.what() ;
      }

      job->attachOut () ;

      jobMgr->_removeJob ( cb->getID(), rc ) ;
      if ( !reuseEDU )
      {
         pEDUMgr->forceUserEDU( cb->getID() ) ;
      }

      if ( !expStr.empty() )
      {
         throw pdGeneralException( rc, expStr ) ;
      }

      PD_TRACE_EXITRC ( SDB_PMDBGJOBENTPNT, rc );
      return SDB_OK ;
   }
Example #19
0
   _rtnContextLob::~_rtnContextLob()
   {
      if ( NULL != _stream && _stream->isOpened() )
      {
         pmdKRCB *krcb = pmdGetKRCB() ;
         pmdEDUMgr *eduMgr = krcb->getEDUMgr() ;
         pmdEDUCB *cb = eduMgr->getEDUByID( eduID() ) ;
         _stream->closeWithException( cb ) ;
      }

      SAFE_OSS_DELETE( _stream ) ;
   }
   /*
      _coordOmStrategyAccessor implement
   */
   _coordOmStrategyAccessor::_coordOmStrategyAccessor( INT64 timeout )
   {
      pmdKRCB *krcb = pmdGetKRCB() ;
      CoordCB *pCoord = krcb->getCoordCB() ;
      pmdOptionsCB *optionsCB = krcb->getOptionCB() ;

      _pOmProxy = pCoord->getResource()->getOmProxy() ;
      _oprTimeout = timeout ;

      optionsCB->getFieldStr( PMD_OPTION_CLUSTER_NAME, _clsName, "" ) ;
      optionsCB->getFieldStr( PMD_OPTION_BUSINESS_NAME, _bizName, "" ) ;
   }
Example #21
0
   INT32 catSplitCheckConflict( BSONObj & match, clsSplitTask & splitTask,
                                BOOLEAN & conflict, pmdEDUCB * cb )
   {
      INT32 rc = SDB_OK ;
      pmdKRCB *krcb = pmdGetKRCB() ;
      SDB_DMSCB *dmsCB = krcb->getDMSCB() ;
      SDB_RTNCB *rtnCB = krcb->getRTNCB() ;
      BSONObj dummyObj ;
      INT64 contextID = -1 ;

      rtnContextBuf buffObj ;
      INT64 startPos = 0 ;

      rc = rtnQuery( CAT_TASK_INFO_COLLECTION, dummyObj, match, dummyObj,
                     dummyObj, 0, cb, 0, -1, dmsCB, rtnCB, contextID ) ;
      PD_RC_CHECK ( rc, PDERROR, "Failed to perform query, rc = %d", rc ) ;

      while ( SDB_OK == rc )
      {
         rc = rtnGetMore( contextID, -1, buffObj, startPos, cb, rtnCB ) ;
         if ( rc )
         {
            if ( SDB_DMS_EOC == rc )
            {
               contextID = -1 ;
               rc = SDB_OK ;
               break ;
            }
            PD_LOG( PDERROR, "Failed to retreive record, rc = %d", rc ) ;
            goto error ;
         }

         rc = _checkSplitTaskConflict( &buffObj, conflict, &splitTask ) ;
         PD_RC_CHECK( rc, PDERROR, "Check split task conflict error, rc: %d",
                      rc ) ;

         if ( conflict )
         {
            break ;
         }
      }

   done:
      if ( -1 != contextID )
      {
         rtnCB->contextDelete ( contextID, cb ) ;
      }
      return rc ;
      return rc ;
   error:
      goto done ;
   }
Example #22
0
 void _dpsLogWrapper::regEventHandler( dpsEventHandler *pHandler )
 {
    SDB_ASSERT( pHandler, "Handle can't be NULL" ) ;
    SDB_ASSERT( FALSE == pmdGetKRCB()->isActive(),
                "Can't register handle when pmd actived" ) ;
    for ( UINT32 i = 0 ; i < _vecEventHandler.size() ; ++i )
    {
       SDB_ASSERT( pHandler != _vecEventHandler[ i ],
                   "Handle can't be same" ) ;
    }
    _vecEventHandler.push_back( pHandler ) ;
    _buf.regEventHandler( pHandler ) ;
 }
Example #23
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_ACTIVE, "_dpsLogWrapper::active" )
   INT32 _dpsLogWrapper::active ()
   {
      INT32 rc = SDB_OK ;
      PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_ACTIVE ) ;

      pmdEDUMgr *pEDUMgr = pmdGetKRCB()->getEDUMgr() ;
      EDUID eduID = PMD_INVALID_EDUID ;

      rc = pEDUMgr->startEDU( EDU_TYPE_LOGGW, (void*)this, &eduID ) ;
      if ( rc )
      {
         PD_LOG( PDERROR, "Start dps log writer failed, rc: %d", rc ) ;
         goto error ;
      }

      rc = pEDUMgr->startEDU( EDU_TYPE_DPSROLLBACK, NULL, &eduID ) ;
      if ( rc )
      {
         PD_LOG( PDERROR, "Start dps trans rollback failed, rc: %d", rc ) ;
         goto error ;
      }

      if ( pmdGetKRCB()->getOptionCB()->archiveOn() )
      {
         rc = pEDUMgr->startEDU( EDU_TYPE_LOGARCHIVEMGR, (void*)this, &eduID ) ;
         if ( rc )
         {
            PD_LOG( PDERROR, "Start dps log archiving failed, rc: %d", rc ) ;
            goto error ;
         }
      }

   done:
      PD_TRACE_EXITRC( SDB__DPSLGWRAPP_ACTIVE, rc ) ;
      return rc ;
   error:
      goto done ;
   }
Example #24
0
   INT32 _pmdController::active ()
   {
      INT32 rc = SDB_OK ;
      pmdEDUParam *pProtocolData = NULL ;
      pmdEDUMgr *pEDUMgr = pmdGetKRCB()->getEDUMgr() ;
      EDUID eduID = PMD_INVALID_EDUID ;

      rc = _restAdptor.init( _fixBufSize, _maxRestBodySize, _restTimeout ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to init rest adaptor, rc: %d", rc ) ;

      rc = pEDUMgr->startEDU( EDU_TYPE_SYNCCLOCK, NULL, &eduID ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_SYNCCLOCK, eduID ) ;

      rc = pEDUMgr->startEDU( EDU_TYPE_TCPLISTENER, (void*)_pTcpListener,
                              &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start tcp listerner, rc: %d",
                   rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_TCPLISTENER, eduID ) ;

      rc = pEDUMgr->waitUntil ( eduID, PMD_EDU_RUNNING ) ;
      PD_RC_CHECK( rc, PDERROR, "Wait Tcp Listerner active failed, rc: %d",
                   rc ) ;

      rc = pEDUMgr->startEDU( EDU_TYPE_RESTLISTENER, (void*)_pHttpListener,
                              &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start rest listerner, rc: %d",
                   rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_RESTLISTENER, eduID ) ;

      rc = pEDUMgr->waitUntil ( eduID, PMD_EDU_RUNNING ) ;
      PD_RC_CHECK( rc, PDERROR, "Wait rest Listener active failed, rc: %d",
                   rc ) ;


      if ( SDB_ROLE_COORD != pmdGetDBRole() )
      {
         UINT32 pageTaskNum = pmdGetOptionCB()->getPageCleanNum() ;
         UINT32 pageIntervel = pmdGetOptionCB()->getPageCleanInterval() ;
         for ( UINT32 i = 0; i < pageTaskNum ; ++i )
         {
            startPageCleanerJob( NULL, (INT32)pageIntervel ) ;
         }
         rtnStartLoadJob() ;
      }

   done:
      return rc ;
   error:
      goto done ;
   }
Example #25
0
   INT32 sdbCatalogueCB::active ()
   {
      INT32 rc = SDB_OK ;
      pmdEDUMgr *pEDUMgr = pmdGetKRCB()->getEDUMgr() ;
      EDUID eduID = PMD_INVALID_EDUID ;

      _catMainCtrl.getAttachEvent()->reset() ;
      rc = pEDUMgr->startEDU ( EDU_TYPE_CATMAINCONTROLLER,
                               (_pmdObjBase*)getMainController(),
                               &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start cat main controller edu, "
                   "rc: %d", rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_CATMAINCONTROLLER, eduID ) ;
      rc = _catMainCtrl.getAttachEvent()->wait( CAT_WAIT_EDU_ATTACH_TIMEOUT ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to wait cat main contoller edu "
                   "attach, rc: %d", rc ) ;

      _catMainCtrl.getAttachEvent()->reset() ;
      rc = pEDUMgr->startEDU ( EDU_TYPE_CATCATALOGUEMANAGER,
                               (_pmdObjBase*)getCatlogueMgr(),
                               &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start catlogue manager edu, "
                   "rc: %d", rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_CATCATALOGUEMANAGER, eduID ) ;
      rc = _catMainCtrl.getAttachEvent()->wait( CAT_WAIT_EDU_ATTACH_TIMEOUT ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to wait catlogue manager edu "
                   "attach, rc: %d", rc ) ;

      _catMainCtrl.getAttachEvent()->reset() ;
      rc = pEDUMgr->startEDU ( EDU_TYPE_CATNODEMANAGER,
                               (_pmdObjBase*)getCatNodeMgr(),
                               &eduID ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to start cat node manager edu, "
                   "rc: %d", rc ) ;
      pEDUMgr->regSystemEDU( EDU_TYPE_CATNODEMANAGER, eduID ) ;
      rc = _catMainCtrl.getAttachEvent()->wait( CAT_WAIT_EDU_ATTACH_TIMEOUT ) ;
      PD_RC_CHECK( rc, PDERROR, "Failed to wait cat node manager edu "
                   "attach, rc: %d", rc ) ;

      pEDUMgr->startEDU ( EDU_TYPE_CATNETWORK, (netRouteAgent*)netWork(),
                          &eduID ) ;
      pEDUMgr->regSystemEDU ( EDU_TYPE_CATNETWORK, eduID ) ;
      rc = pEDUMgr->waitUntil( EDU_TYPE_CATNETWORK, PMD_EDU_RUNNING ) ;
      PD_RC_CHECK( rc, PDERROR, "Wait CATNET active failed, rc: %d", rc ) ;

   done:
      return rc ;
   error:
      goto done ;
   }
Example #26
0
   /*
      _pmdEDUCB implement
   */
   _pmdEDUCB::_pmdEDUCB( _pmdEDUMgr *mgr, EDU_TYPES type )
   : _tid( 0 ),
   _processEventCount( 0 ),
   _eduMgr( mgr ),
   _eduType( type ),
   _ctrlFlag( 0 ),
   _writingDB( FALSE ),
   _writingTime( 0 ),
   _threadHdl( 0 ),
#if defined (_LINUX)
   _threadID( 0 ),
#endif
   _pClientSock( NULL )
   {
      _Name[0]          = 0 ;
      _pSession         = NULL ;
      _pCompressBuff    = NULL ;
      _compressBuffLen  = 0 ;
      _pUncompressBuff  = NULL ;
      _uncompressBuffLen= 0 ;
      _totalCatchSize   = 0 ;
      _totalMemSize     = 0 ;
      _isDoRollback     = FALSE ;

#if defined ( SDB_ENGINE )
      _pCoordSession    = NULL ;
      _beginLsn         = 0 ;
      _endLsn           = 0 ;
      _lsnNumber        = 0 ;
      _relatedTransLSN  = DPS_INVALID_LSN_OFFSET ;
      _curTransLSN      = DPS_INVALID_LSN_OFFSET ;
      _curTransID       = DPS_INVALID_TRANS_ID ;
      _pTransNodeMap    = NULL ;
      _transRC          = SDB_OK ;

      _alignedMem       = NULL ;
      _alignedMemSize   = 0 ;

      _curRequestID     = 1 ;
      _dmsLockLevel     = 0 ;

      _monCfgCB = *( (monConfigCB*)(pmdGetKRCB()->getMonCB()) ) ;
#endif // SDB_ENGINE

      _pErrorBuff = (CHAR *)SDB_OSS_MALLOC( EDU_ERROR_BUFF_SIZE + 1 ) ;
      if ( _pErrorBuff )
      {
         ossMemset( _pErrorBuff, 0, EDU_ERROR_BUFF_SIZE + 1 ) ;
      }
   }
Example #27
0
   // PD_TRACE_DECLARE_FUNCTION ( SDB_COORDSN_CHECKREMOTEROUTEID, "CoordSession::checkRemoteRouteID" )
   INT32 CoordSession::checkRemoteRouteID( const MsgRouteID & routeID )
   {
      INT32 rc = SDB_OK;
      PD_TRACE_ENTRY ( SDB_COORDSN_CHECKREMOTEROUTEID );
      netMultiRouteAgent *pRouteAgent = pmdGetKRCB()->getCoordCB()->getRouteAgent();
      SDB_ASSERT( _pEduCB, "_pEduCB can't be NULL!" );
      MsgCoordCheckRouteID msgReq;
      msgReq.header.requestID = 0;
      msgReq.header.messageLength = sizeof( MsgCoordCheckRouteID );
      msgReq.header.opCode = MSG_COOR_CHECK_ROUTEID_REQ;
      msgReq.header.routeID.value = 0;
      msgReq.header.TID = _pEduCB->getTID();
      msgReq.dstRouteID = routeID;
      REQUESTID_MAP requestIdMap;
      REPLY_QUE replyQue;

      rc = rtnCoordSendRequestToNodeWithoutCheck( (void *)(&msgReq), routeID,
                                                pRouteAgent, _pEduCB,
                                                requestIdMap );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to send the message to the node"
                  "(groupID=%u, nodeID=%u, serviceID=%u)",
                  routeID.columns.groupID,
                  routeID.columns.nodeID,
                  routeID.columns.serviceID );
      rc = rtnCoordGetReply( _pEduCB, requestIdMap, replyQue,
                             MSG_COOR_CHECK_ROUTEID_RSP );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to get reply from node"
                  "(groupID=%u, nodeID=%u, serviceID=%u, rc=%d)",
                  routeID.columns.groupID,
                  routeID.columns.nodeID,
                  routeID.columns.serviceID,
                  rc );
      while ( !replyQue.empty() )
      {
         MsgOpReply *pReply = NULL;
         pReply = (MsgOpReply *)(replyQue.front());
         SDB_ASSERT( pReply, "pReply can't be NULL!" );
         replyQue.pop();
         rc = rc ? rc : pReply->flags;
         SDB_OSS_FREE( pReply );
      }
   done:
      PD_TRACE_EXIT ( SDB_COORDSN_CHECKREMOTEROUTEID );
      return rc;
   error:
      rtnCoordClearRequest( _pEduCB, requestIdMap );
      goto done;
   }
Example #28
0
int pmdEDUMgr::returnEDU(EDUID eduID, bool force, bool* destroyed)
{
	int rc = EDB_OK;
	EDU_TYPES type = EDU_TYPE_UNKNOWN;
	pmdEDUCB* eduCB = NULL;
	std::map<EDUID, pmdEDUCB*>::iterator it;
	_mutex.get_shared();
	if (_runQueue.end() == (it = _runQueue.find(eduID))) {
		if (_idleQueue.end() == (it = _idleQueue.find(eduID))) {
			rc = EDB_SYS;
			*destroyed = false;
			_mutex.release_shared();
			goto error;	
		}	
	}	

	eduCB = (*it).second;
	if (eduCB) {
		type = eduCB->getType();	
	}
	_mutex.release_shared();

	if (!isPoolable(type) || force || isDestroyed()
		|| size() > (unsigned int) pmdGetKRCB()->getMaxPool())
	{
		rc = _destroyEDU(eduID);	
		if (destroyed) {
			if (EDB_OK == rc || EDB_SYS == rc) {
				*destroyed = true;
			} else {
				*destroyed = false;
			}		
		}
	} else {
		rc = _deactivateEDU(eduID);
		if (destroyed) {
			if (EDB_SYS == rc) {
				*destroyed = true;	
			} else {
				*destroyed = false;	
			}
		}	
	}

done:
	return rc;
error:
	goto done;
}
Example #29
0
   INT32 rtnCoordAggregate::execute( CHAR *pReceiveBuffer,
                                     SINT32 packSize,
                                     pmdEDUCB *cb,
                                     MsgOpReply &replyHeader,
                                     rtnContextBuf *buf )
   {
      INT32 rc = SDB_OK;
      MsgHeader *pHeader = (MsgHeader *)pReceiveBuffer;
      CHAR *pCollectionName = NULL;
      CHAR *pObjs = NULL;
      INT32 count = 0;
      BSONObj objs;
      SINT64 contextID = -1;

      replyHeader.contextID = -1;
      replyHeader.flags = SDB_OK;
      replyHeader.numReturned = 0;
      replyHeader.startFrom = 0;
      replyHeader.header.messageLength = sizeof( MsgOpReply );
      replyHeader.header.opCode = MSG_BS_AGGREGATE_RSP;
      replyHeader.header.requestID = pHeader->requestID;
      replyHeader.header.routeID.value = 0;
      replyHeader.header.TID = pHeader->TID;

      rc = msgExtractAggrRequest( pReceiveBuffer, &pCollectionName, &pObjs, count );
      PD_RC_CHECK( rc, PDERROR, "failed to parse aggregate request(rc=%d)", rc );

      try
      {
         objs = BSONObj( pObjs );
      }
      catch ( std::exception &e )
      {
         PD_RC_CHECK( rc, PDERROR,
                     "failed to execute aggregate, received unexpecte error:%s",
                     e.what() );
      }
      rc = pmdGetKRCB()->getAggrCB()->build( objs, count, pCollectionName,
                                             cb, contextID );
      PD_RC_CHECK( rc, PDERROR,
                  "failed to execute aggregation operation(rc=%d)",
                  rc );
      replyHeader.contextID = contextID;
   done:
      return rc;
   error:
      replyHeader.flags = rc;
      goto done;
   }
Example #30
0
   /*
      ENTRY POINTER FUNCTIONS
   */
   INT32 pmdSyncClockEntryPoint( pmdEDUCB * cb, void * arg )
   {
      ossTick tmp ;
      pmdKRCB *pKrcb = pmdGetKRCB() ;

      pKrcb->getEDUMgr()->activateEDU( cb ) ;

      while ( !cb->isDisconnected() )
      {
         pKrcb->syncCurTime() ;
         pmdUpdateDBTick() ;
         ossSleep( PMD_SYNC_CLOCK_INTERVAL ) ;
      }
      return SDB_OK ;
   }