// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSK_ISCONN, "ossSocket::isConnected" )
BOOLEAN _ossSocket::isConnected ()
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB_OSSSK_ISCONN );
if ( !_init )
{
PD_TRACE_EXIT ( SDB_OSSSK_ISCONN );
return FALSE ;
}
#if defined (_WINDOWS)
rc = ::send ( _fd, "", 0, 0 ) ;
if ( SOCKET_ERROR == rc )
#else
rc = ::recv ( _fd, NULL, 0, MSG_DONTWAIT ) ;
if ( 0 == rc )
#endif
{
PD_TRACE_EXIT ( SDB_OSSSK_ISCONN );
return FALSE ;
}
PD_TRACE_EXIT ( SDB_OSSSK_ISCONN );
return TRUE ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__RTNJOBMGR_FINDJOB, "_rtnJobMgr::findJob" )
_rtnBaseJob* _rtnJobMgr::findJob( EDUID eduID, INT32 *pResult )
{
PD_TRACE_ENTRY ( SDB__RTNJOBMGR_FINDJOB ) ;
{
ossScopedLock lock ( &_latch, SHARED ) ;
std::map<EDUID, _rtnBaseJob*>::iterator it = _mapJobs.find( eduID ) ;
if ( it != _mapJobs.end() )
{
PD_TRACE_EXIT ( SDB__RTNJOBMGR_FINDJOB ) ;
return it->second ;
}
}
INT32 res = SDB_OK ;
{
ossScopedLock lock ( &_latch, EXCLUSIVE ) ;
std::map<EDUID, INT32>::iterator itRes = _mapResult.find( eduID ) ;
if ( itRes != _mapResult.end() )
{
res = itRes->second ;
_mapResult.erase( itRes ) ;
}
}
if ( pResult )
{
*pResult = res ;
}
PD_TRACE_EXIT ( SDB__RTNJOBMGR_FINDJOB ) ;
return NULL ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__PMDEDUCB_GETINFO, "_pmdEDUCB::getInfo" )
const CHAR *_pmdEDUCB::getInfo ( EDU_INFO_TYPE type )
{
PD_TRACE_ENTRY ( SDB__PMDEDUCB_GETINFO );
UINT32 buffSize = 0 ;
CHAR *buff = _getBuffInfo ( type, buffSize ) ;
if ( buff && buff[0] != 0 )
{
PD_TRACE_EXIT ( SDB__PMDEDUCB_GETINFO );
return buff ;
}
PD_TRACE_EXIT ( SDB__PMDEDUCB_GETINFO );
return NULL ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSWLKSTK, "ossWalkStack" )
void ossWalkStack ( UINT32 framesToSkip,
OSS_INSTRUCTION_PTR * ppInstruction,
UINT32 framesRequested )
{
PD_TRACE_ENTRY ( SDB_OSSWLKSTK );
void * syms[ OSS_MAX_BACKTRACE_FRAMES_SUPPORTED + 1 ] = { 0 } ;
UINT32 numFrames, framesOnStk, i ;
if ( NULL != ppInstruction )
{
numFrames = OSS_MIN( framesToSkip + framesRequested,
OSS_MAX_BACKTRACE_FRAMES_SUPPORTED ) ;
framesOnStk = (UINT32_64)backtrace( syms, numFrames ) ;
for ( i = 0 ; i < framesRequested ; i++ )
{
ppInstruction[i] = NULL ;
}
for ( i = 0 ; i < ( framesOnStk - framesToSkip ) ; i++ )
{
ppInstruction[i] = ( OSS_INSTRUCTION_PTR )syms[ framesToSkip + i ] ;
}
}
PD_TRACE_EXIT ( SDB_OSSWLKSTK );
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSDUMPREGSINFO2, "ossDumpRegistersInfo" )
void ossDumpRegistersInfo( ossSignalContext pContext,
ossPrimitiveFileOp * trapFile )
{
PD_TRACE_ENTRY ( SDB_OSSDUMPREGSINFO2 );
greg_t * r ;
if ( ( NULL != trapFile ) && trapFile->isValid() )
{
if ( NULL != pContext )
{
r = pContext->uc_mcontext.gregs ;
trapFile->fWrite( "Registers:"OSS_NEWLINE
"eax %08X ebx %08X ecx %08X edx %08X"OSS_NEWLINE
"ebp %08X esp %08X edi %08X esi %08X"OSS_NEWLINE
"efl %08X eip %08X"OSS_NEWLINE
"cs %04hx ss %04hx ds %04hx "
"ss %04hx fs %04hx ds %04hx"OSS_NEWLINE,
r[REG_EAX], r[REG_EBX], r[REG_ECX], r[REG_EDX],
r[REG_EBP], r[REG_ESP], r[REG_EDI], r[REG_ESI],
r[REG_EFL], r[REG_EIP],
r[REG_CS], r[REG_SS], r[REG_DS],
r[REG_ES], r[REG_FS], r[REG_GS] ) ;
}
else
{
trapFile->Write (OSS_NEWLINE"Unable to dump registers"OSS_NEWLINE) ;
}
}
PD_TRACE_EXIT ( SDB_OSSDUMPREGSINFO2 );
}
BOOLEAN isSameFrom( const qgmOPFieldVec & left, const qgmOPFieldVec & right )
{
PD_TRACE_ENTRY( SDB__QGMISSAMEFROM ) ;
if ( left.size() != right.size() )
{
return FALSE ;
}
UINT32 i = 0 ;
while ( i < left.size() )
{
qgmOpField field ;
if ( ( !right[i].alias.empty() &&
left[i].value.attr() != right[i].alias ) ||
( right[i].alias.empty() &&
left[i].value.attr() != right[i].value.attr() ) )
{
return FALSE ;
}
++i ;
}
PD_TRACE_EXIT( SDB__QGMISSAMEFROM ) ;
return TRUE ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALDATASIZE, "_dmsStorageUnit::totalDataSize" )
INT64 _dmsStorageUnit::totalDataSize( UINT32 type ) const
{
INT64 totalSize = 0 ;
PD_TRACE_ENTRY ( SDB__DMSSU_TOTALDATASIZE ) ;
if ( !_pDataSu || !_pIndexSu || !_pLobSu )
{
goto done ;
}
if ( type & DMS_SU_DATA )
{
totalSize += ( totalDataPages( DMS_SU_DATA ) <<
_pDataSu->pageSizeSquareRoot() ) ;
}
if ( type & DMS_SU_INDEX )
{
totalSize += ( totalDataPages( DMS_SU_INDEX ) <<
_pDataSu->pageSizeSquareRoot() ) ;
}
if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() )
{
totalSize += _pLobSu->getLobData()->getDataSz() ;
}
done:
PD_TRACE1 ( SDB__DMSSU_TOTALDATASIZE,
PD_PACK_LONG ( totalSize ) ) ;
PD_TRACE_EXIT ( SDB__DMSSU_TOTALDATASIZE ) ;
return totalSize ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__PSH2SNDQUEUE, "_dpsReplicaLogMgr::_push2SendQueue" )
void _dpsReplicaLogMgr::_push2SendQueue( const dpsPageMeta &allocated )
{
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__PSH2SNDQUEUE );
SDB_ASSERT( allocated.valid(), "impossible" ) ;
for ( UINT32 i = 0; i < allocated.pageNum; ++i )
{
_dpsLogPage *page = PAGE(allocated.beginSub + i) ;
if ( 0 == page->getLastSize() )
{
if ( !_restoreFlag )
{
_queue.push ( page ) ;
_queSize.inc() ;
}
else
{
_idleSize.add( page->getLength() );
page->clear() ;
}
}
}
PD_TRACE_EXIT ( SDB__DPSRPCMGR__PSH2SNDQUEUE );
return ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_SCOPE_INIT, "Scope::init" )
BOOLEAN Scope::init()
{
BOOLEAN ret = FALSE ;
PD_TRACE_ENTRY ( SDB_SCOPE_INIT );
SDB_ASSERT( globalEngine, "Script engine has not been initialized" );
SDB_ASSERT( ! _context && ! _global, "Can't init a scope twice" );
_context = JS_NewContext( globalEngine->_runtime, 1024 * 1024 ) ;
VERIFY( _context );
JS_SetOptions( _context, JSOPTION_VAROBJFIX );
JS_SetVersion( _context, JSVERSION_LATEST );
JS_SetErrorReporter( _context, sdbReportError );
_global = JS_NewCompartmentAndGlobalObject( _context, &global_class, NULL );
VERIFY( _global );
VERIFY( JS_InitStandardClasses( _context, _global ) );
VERIFY( InitDbClasses( _context, _global ) ) ;
VERIFY ( SDB_OK == evalInitScripts ( this ) ) ;
ret = TRUE ;
done :
PD_TRACE_EXIT ( SDB_SCOPE_INIT );
return ret ;
error :
goto done ;
}
void migMaster::popFromQueue( pmdEDUCB *eduCB,
UINT32 &offset, UINT32 &size,
UINT32 &line, UINT32 &column )
{
PD_TRACE_ENTRY ( SDB__MIGLOADJSONPS__POPFROMQUEUE );
BOOLEAN isPop = FALSE ;
_dataQueue data ;
do
{
isPop = _queue.timed_wait_and_pop ( data, 100 ) ;
}while ( !isPop &&
!eduCB->isInterrupted() &&
!eduCB->isDisconnected() &&
!eduCB->isForced() &&
_sock->isConnected() ) ;
if ( isPop )
{
offset = data.offset ;
size = data.size ;
line = data.line ;
column = data.column ;
}
else
{
offset = 0 ;
size = 0 ;
line = 0 ;
column = 0 ;
}
PD_TRACE_EXIT ( SDB__MIGLOADJSONPS__POPFROMQUEUE );
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU, "_dmsStorageUnit::_dmsStorageUnit" )
_dmsStorageUnit::_dmsStorageUnit ( const CHAR *pSUName, UINT32 sequence,
INT32 pageSize, INT32 lobPageSize )
:_apm(this),
_pDataSu( NULL ),
_pIndexSu( NULL ),
_pLobSu( NULL )
{
PD_TRACE_ENTRY ( SDB__DMSSU ) ;
SDB_ASSERT ( pSUName, "name can't be null" ) ;
if ( 0 == pageSize )
{
pageSize = DMS_PAGE_SIZE_DFT ;
}
if ( 0 == lobPageSize )
{
lobPageSize = DMS_DEFAULT_LOB_PAGE_SZ ;
}
CHAR dataFileName[DMS_SU_FILENAME_SZ + 1] = {0} ;
CHAR idxFileName[DMS_SU_FILENAME_SZ + 1] = {0} ;
_storageInfo._pageSize = pageSize ;
_storageInfo._lobdPageSize = lobPageSize ;
ossStrncpy( _storageInfo._suName, pSUName, DMS_SU_NAME_SZ ) ;
_storageInfo._suName[DMS_SU_NAME_SZ] = 0 ;
_storageInfo._sequence = sequence ;
_storageInfo._secretValue = ossPack32To64( (UINT32)time(NULL),
(UINT32)(ossRand()*239641) ) ;
ossSnprintf( dataFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s",
_storageInfo._suName, sequence, DMS_DATA_SU_EXT_NAME ) ;
ossSnprintf( idxFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s",
_storageInfo._suName, sequence, DMS_INDEX_SU_EXT_NAME ) ;
_pDataSu = SDB_OSS_NEW dmsStorageData( dataFileName, &_storageInfo ) ;
if ( _pDataSu )
{
_pIndexSu = SDB_OSS_NEW dmsStorageIndex( idxFileName, &_storageInfo,
_pDataSu ) ;
}
if ( NULL != _pDataSu && NULL != _pIndexSu )
{
ossMemset( dataFileName, 0, sizeof( dataFileName ) ) ;
ossMemset( idxFileName, 0 , sizeof( idxFileName ) ) ;
ossSnprintf( dataFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s",
_storageInfo._suName, _storageInfo._sequence,
DMS_LOB_META_SU_EXT_NAME ) ;
ossSnprintf( idxFileName, DMS_SU_FILENAME_SZ, "%s.%d.%s",
_storageInfo._suName, _storageInfo._sequence,
DMS_LOB_DATA_SU_EXT_NAME ) ;
_pLobSu = SDB_OSS_NEW dmsStorageLob( dataFileName, idxFileName,
&_storageInfo, _pDataSu ) ;
}
PD_TRACE_EXIT ( SDB__DMSSU ) ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_COMMITLSN, "_dpsLogWrapper::commitLsn" )
DPS_LSN _dpsLogWrapper::commitLsn()
{
PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_COMMITLSN ) ;
DPS_LSN lsn = _buf.commitLsn() ;
PD_TRACE_EXIT( SDB__DPSLGWRAPP_COMMITLSN ) ;
return lsn ;
}
const MsgRouteID &_clsSrcSelector::selectPrimary ( UINT32 groupID,
MSG_ROUTE_SERVICE_TYPE type )
{
PD_TRACE_ENTRY ( SDB__CLSSRCSL_SLPMY ) ;
if ( _noRes > CLS_FS_NORES_TIMEOUT )
{
_src.value = MSG_INVALID_ROUTEID ;
}
if ( MSG_INVALID_ROUTEID != _src.value )
{
goto done ;
}
{
_noRes = 0 ;
INT32 rc = SDB_OK ;
rc = sdbGetShardCB()->syncUpdateGroupInfo( groupID ) ;
if ( SDB_OK != rc )
{
goto done ;
}
_nodeMgrAgent->lock_r () ;
_nodeMgrAgent->groupPrimaryNode( groupID, _src, type ) ;
_nodeMgrAgent->release_r () ;
}
done:
PD_TRACE_EXIT ( SDB__CLSSRCSL_SLPMY ) ;
return _src ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_GETCURRENTLSN, "_dpsLogWrapper::getCurrentLsn" )
DPS_LSN _dpsLogWrapper::getCurrentLsn()
{
PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_GETCURRENTLSN ) ;
DPS_LSN lsn = _buf.currentLsn() ;
PD_TRACE_EXIT( SDB__DPSLGWRAPP_GETCURRENTLSN ) ;
return lsn ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALFREEPAGES, "_dmsStorageUnit::totalFreePages" )
INT64 _dmsStorageUnit::totalFreePages ( UINT32 type ) const
{
INT64 freePages = 0 ;
PD_TRACE_ENTRY ( SDB__DMSSU_TOTALFREEPAGES ) ;
if ( !_pDataSu || !_pIndexSu || !_pLobSu )
{
goto done ;
}
if ( type & DMS_SU_DATA )
{
freePages += (INT64)_pDataSu->freePageNum() ;
}
if ( type & DMS_SU_INDEX )
{
freePages += (INT64)_pIndexSu->freePageNum() ;
}
if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() )
{
freePages += (INT64)_pLobSu->freePageNum() ;
}
done:
PD_TRACE1 ( SDB__DMSSU_TOTALFREEPAGES,
PD_PACK_INT ( freePages ) ) ;
PD_TRACE_EXIT ( SDB__DMSSU_TOTALFREEPAGES ) ;
return freePages ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__OSSSK__OSSSK3, "_ossSocket::_ossSocket" )
_ossSocket::_ossSocket ( SOCKET *sock, INT32 timeoutMilli )
{
SDB_ASSERT ( sock, "Input sock is NULL" ) ;
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__OSSSK__OSSSK3 );
_fd = *sock ;
_init = TRUE ;
_timeout = timeoutMilli ;
_closeWhenDestruct = TRUE ;
_addressLen = sizeof ( _sockAddress ) ;
ossMemset ( &_peerAddress, 0, sizeof(sockaddr_in) ) ;
_peerAddressLen = sizeof ( _peerAddress ) ;
ossInitSocket() ;
rc = getsockname ( _fd, (sockaddr*)&_sockAddress, &_addressLen ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to getsockname from socket %d", _fd ) ;
_init = FALSE ;
}
else
{
rc = getpeername ( _fd, (sockaddr*)&_peerAddress, &_peerAddressLen ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to getpeername from socket %d", _fd ) ;
}
}
setTimeout ( _timeout ) ;
PD_TRACE_EXIT ( SDB__OSSSK__OSSSK3 );
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSSYMINIT, "ossSymInitialize" )
UINT32 ossSymInitialize( HANDLE phProcess,
CHAR * pUserSearchPath,
BOOLEAN bInvadeProcess )
{
PD_TRACE_ENTRY ( SDB_OSSSYMINIT );
static BOOLEAN s_bSymInitialized = false ;
UINT32 rc = ERROR_SUCCESS ;
WaitForSingleObject( ossGetSysMutexHandle( _SymInitialize ), INFINITE ) ;
if ( ! s_bSymInitialized )
{
if ( SymInitialize( phProcess, pUserSearchPath, bInvadeProcess ) )
{
s_bSymInitialized = TRUE ;
}
else
{
rc = GetLastError() ;
}
}
ReleaseMutex ( ossGetSysMutexHandle( _SymInitialize ) ) ;
if ( ERROR_SUCCESS != rc )
{
SetLastError( rc ) ;
}
PD_TRACE1 ( SDB_OSSSYMINIT, PD_PACK_UINT(rc) );
PD_TRACE_EXIT ( SDB_OSSSYMINIT );
return rc ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSDMPSYSTM, "ossDumpSystemTime" )
void ossDumpSystemTime( ossPrimitiveFileOp * trapFile )
{
PD_TRACE_ENTRY ( SDB_OSSDMPSYSTM );
struct tm otm ;
struct timeval tv ;
struct timezone tz ;
time_t tt ;
gettimeofday ( &tv, &tz ) ;
tt = tv.tv_sec ;
localtime_s ( &otm, &tt ) ;
if ( ( NULL != trapFile ) && trapFile->isValid() )
{
trapFile->fWrite ( "Timestamp: %04d-%02d-%02d-%02d.%02d.%02d.%06d"
OSS_NEWLINE,
otm.tm_year+1900, // 1) Year (UINT32)
otm.tm_mon+1, // 2) Month (UINT32)
otm.tm_mday, // 3) Day (UINT32)
otm.tm_hour, // 4) Hour (UINT32)
otm.tm_min, // 5) Minute (UINT32)
otm.tm_sec, // 6) Second (UINT32)
tv.tv_usec // 7) Microsecond (UINT32)
);
}
PD_TRACE_EXIT ( SDB_OSSDMPSYSTM );
}
const MsgRouteID &_clsSrcSelector::selected( BOOLEAN isFullSync )
{
PD_TRACE_ENTRY ( SDB__CLSSRCSL_SLTED ) ;
MsgRouteID &id = _src ;
if ( _noRes > CLS_FS_NORES_TIMEOUT )
{
_src.value = MSG_INVALID_ROUTEID ;
}
if ( MSG_INVALID_ROUTEID != _src.value )
{
goto done ;
}
_noRes = 0 ;
if ( isFullSync )
{
id = getFullSyncSrc() ;
goto done ;
}
else
{
id = getSyncSrc() ;
goto done ;
}
done :
PD_TRACE_EXIT ( SDB__CLSSRCSL_SLTED ) ;
return id ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_GETSTATINFO, "_dmsStorageUnit::getStatInfo" )
void _dmsStorageUnit::getStatInfo( dmsStorageUnitStat & statInfo )
{
PD_TRACE_ENTRY ( SDB__DMSSU_GETSTATINFO ) ;
ossMemset( &statInfo, 0, sizeof( dmsStorageUnitStat ) ) ;
dmsMBStatInfo *mbStat = NULL ;
_pDataSu->_metadataLatch.get_shared() ;
dmsStorageData::COLNAME_MAP_IT it = _pDataSu->_collectionNameMap.begin() ;
while ( it != _pDataSu->_collectionNameMap.end() )
{
mbStat = &_pDataSu->_mbStatInfo[it->second] ;
++statInfo._clNum ;
statInfo._totalCount += mbStat->_totalRecords ;
statInfo._totalDataPages += mbStat->_totalDataPages ;
statInfo._totalIndexPages += mbStat->_totalIndexPages ;
statInfo._totalLobPages += mbStat->_totalLobPages ;
statInfo._totalDataFreeSpace += mbStat->_totalDataFreeSpace ;
statInfo._totalIndexFreeSpace += mbStat->_totalIndexFreeSpace ;
++it ;
}
_pDataSu->_metadataLatch.release_shared() ;
PD_TRACE_EXIT ( SDB__DMSSU_GETSTATINFO ) ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__OPTAPHELP__EVALEST, "_optAccessPlanHelper::_evalEstimation" )
void _optAccessPlanHelper::_evalEstimation ( optCollectionStat *pCollectionStat )
{
PD_TRACE_ENTRY( SDB__OPTAPHELP__EVALEST ) ;
double predSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ;
double scanSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ;
double tmpSelectivity = OPT_MTH_DEFAULT_SELECTIVITY ;
UINT32 tmpCPUCost = OPT_MTH_DEFAULT_CPU_COST ;
if ( getMatchTree() != NULL )
{
if ( pCollectionStat )
{
predSelectivity = pCollectionStat->evalPredicateSet(
_predicateSet, mthEnabledMixCmp(), scanSelectivity ) ;
}
getMatchTree()->evalEstimation( pCollectionStat, tmpSelectivity,
tmpCPUCost ) ;
tmpSelectivity *= predSelectivity ;
}
_estSelectivity = OPT_ROUND_SELECTIVITY( tmpSelectivity ) ;
_predSelectivity = OPT_ROUND_SELECTIVITY( predSelectivity ) ;
_scanSelectivity = OPT_ROUND_SELECTIVITY( scanSelectivity ) ;
_estCPUCost = tmpCPUCost ;
_isEstimated = TRUE ;
PD_TRACE_EXIT( SDB__OPTAPHELP__EVALEST ) ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_NOTIFY, "_clsSyncManager::notify" )
void _clsSyncManager::notify( const DPS_LSN_OFFSET &offset )
{
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_NOTIFY ) ;
SDB_ASSERT( DPS_INVALID_LSN_OFFSET != offset,
"offset should not be invalid" ) ;
_MsgSyncNotify msg ;
msg.header.TID = CLS_TID_REPL_SYC ;
_info->mtx.lock_r() ;
for ( UINT32 i = 0; i < _validSync ; i++ )
{
if ( 0 == _notifyList[i].id.value )
{
SDB_ASSERT( FALSE, "impossible" ) ;
}
else if ( offset == _notifyList[i].offset )
{
msg.header.routeID = _notifyList[i].id ;
_agent->syncSend( _notifyList[i].id, &msg ) ;
}
else
{
}
}
_info->mtx.release_r() ;
PD_TRACE_EXIT ( SDB__CLSSYNCMAG_NOTIFY ) ;
return ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__GETSTARTLSN, "_dpsReplicaLogMgr::_getStartLsn" )
DPS_LSN _dpsReplicaLogMgr::_getStartLsn ()
{
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__GETSTARTLSN );
UINT32 begin = _begin ;
DPS_LSN lsn ;
for ( UINT32 count = 0 ; count < _pageNum; count++ )
{
lsn = PAGE(begin)->getBeginLSN () ;
if ( !lsn.invalid() )
{
goto done ;
}
if ( begin == _work )
{
break ;
}
begin = _incPageID ( begin ) ;
}
done :
PD_TRACE_EXIT ( SDB__DPSRPCMGR__GETSTARTLSN );
return lsn ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_GETSYNCSRC, "_clsSyncManager::getSyncSrc" )
MsgRouteID _clsSyncManager::getSyncSrc( const set<UINT64> &blacklist )
{
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_GETSYNCSRC ) ;
MsgRouteID res ;
res.value = MSG_INVALID_ROUTEID ;
_info->mtx.lock_r() ;
map<UINT64, _clsSharingStatus *>::iterator itr =
_info->alives.find( _info->primary.value ) ;
if ( _info->alives.end() != itr &&
CLS_SYNC_STATUS_PEER ==
itr->second->beat.syncStatus )
{
res.value = itr->first ;
goto done ;
}
else
{
MsgRouteID ids[CLS_SYNC_SET_NUM] ;
UINT32 validNum = 0 ;
itr = _info->alives.begin() ;
for ( ; itr != _info->alives.end(); itr++ )
{
if ( CLS_SYNC_STATUS_PEER == itr->second->beat.syncStatus &&
0 == blacklist.count( itr->first ) )
{
ids[validNum++].value = itr->first ;
}
}
if ( 0 == validNum )
{
itr = _info->alives.begin() ;
for ( ; itr != _info->alives.end(); itr++ )
{
if ( CLS_SYNC_STATUS_RC == itr->second->beat.syncStatus &&
itr->first != _info->primary.value &&
0 == blacklist.count( itr->first ))
{
ids[validNum++].value = itr->first ;
}
}
if ( 0 != validNum )
{
res.value = ids[ossRand() % validNum].value ;
}
else
{
res.value = _info->primary.value ;
}
}
else
{
res.value = ids[ossRand() % validNum].value ;
}
}
done:
_info->mtx.release_r() ;
PD_TRACE_EXIT ( SDB__CLSSYNCMAG_GETSYNCSRC ) ;
return res ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__MRGPAGE, "_dpsReplicaLogMgr::_mergePage" )
void _dpsReplicaLogMgr::_mergePage( const CHAR *src,
UINT32 len,
UINT32 &workSub,
UINT32 &offset )
{
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__MRGPAGE ) ;
UINT32 needcpy = len ;
UINT32 srcOffset = 0 ;
UINT32 pageIdle = 0 ;
UINT32 cpylen = 0 ;
while ( needcpy > 0 )
{
dpsLogPage *page = PAGE(workSub) ;
pageIdle = page->getBufSize() - offset ;
cpylen = pageIdle < needcpy ? pageIdle : needcpy ;
page->fill( offset, src + srcOffset, cpylen ) ;
needcpy -= cpylen ;
srcOffset += cpylen ;
offset += cpylen ;
if ( offset == page->getBufSize() )
{
workSub++ ;
offset = 0 ;
}
}
PD_TRACE_EXIT ( SDB__DPSRPCMGR__MRGPAGE ) ;
return;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_CUT, "_clsSyncManager::cut" )
void _clsSyncManager::cut( UINT32 alives )
{
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_CUT ) ;
SDB_ASSERT( alives <= _validSync, "impossible" ) ;
if ( _validSync < alives )
{
PD_LOG( PDWARNING, "sync: alives is bigger than valid sync."
"[alives:%d][valid:%d]", alives, _validSync ) ;
goto done ;
}
{
_clsSyncSession session ;
for ( SINT32 i = (SINT32)_validSync - 1 ; i > (SINT32)alives - 1 ;
--i )
{
_mtxs[i].get() ;
while ( SDB_OK == _syncList[i].pop( session ) )
{
session.eduCB->getEvent().signal ( SDB_CLS_WAIT_SYNC_FAILED ) ;
}
_mtxs[i].release() ;
}
}
done:
PD_TRACE_EXIT ( SDB__CLSSYNCMAG_CUT ) ;
return ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_CLSCATAMATCHER_ISOPOBJ, "clsCatalogMatcher::isOpObj" )
BOOLEAN clsCatalogMatcher::isOpObj( const bson::BSONObj obj )
{
BOOLEAN result = FALSE;
PD_TRACE_ENTRY ( SDB_CLSCATAMATCHER_ISOPOBJ ) ;
try
{
BSONObjIterator iter( obj );
while ( iter.more() )
{
BSONElement beTmp = iter.next();
const CHAR *pFieldName = beTmp.fieldName();
if ( MTH_OPERATOR_EYECATCHER == pFieldName[0])
{
result = TRUE;
break;
}
}
}
catch ( std::exception &e )
{
PD_LOG( PDERROR, "failed to check the obj occured unexpected "
"error:%s", e.what() ) ;
}
PD_TRACE_EXIT ( SDB_CLSCATAMATCHER_ISOPOBJ ) ;
return result;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG__WAKE, "_clsSyncManager::_wake" )
void _clsSyncManager::_wake( CLS_WAKE_PLAN &plan )
{
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG__WAKE ) ;
SDB_ASSERT( plan.size() <= CLS_REPLSET_MAX_NODE_SIZE - 1,
"plan size should <= CLS_REPLSET_MAX_NODE_SIZE - 1" ) ;
_clsSyncSession session ;
UINT32 sub = 0 ;
CLS_WAKE_PLAN::reverse_iterator ritr = plan.rbegin();
while ( ritr != plan.rend() )
{
DPS_LSN lsn ;
lsn.offset = *ritr ;
_mtxs[sub].get() ;
_checkList[sub] = lsn.offset ;
while ( SDB_OK == _syncList[sub].root( session ) )
{
if ( 0 < lsn.compareOffset( session.endLsn ) )
{
session.eduCB->getEvent().signal ( SDB_OK ) ;
_syncList[sub].pop( session ) ;
}
else
{
break ;
}
}
_mtxs[sub].release() ;
++ritr ;
++sub ;
}
PD_TRACE_EXIT ( SDB__CLSSYNCMAG__WAKE ) ;
}
BSONObj qgmMerge( const BSONObj &left, const BSONObj &right )
{
PD_TRACE_ENTRY( SDB__QGMMERGE ) ;
BSONObj obj ;
BSONObjBuilder builder ;
try
{
BSONObjIterator itr1( left ) ;
while ( itr1.more() )
{
builder.append( itr1.next() ) ;
}
BSONObjIterator itr2( right ) ;
while ( itr2.more() )
{
builder.append( itr2.next() ) ;
}
obj = builder.obj() ;
}
catch ( std::exception &e )
{
PD_LOG( PDERROR, "unexpected err happened:%s",
e.what() ) ;
}
PD_TRACE_EXIT( SDB__QGMMERGE ) ;
return obj ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSU_TOTALDATAPAGES, "_dmsStorageUnit::totalDataPages" )
INT64 _dmsStorageUnit::totalDataPages( UINT32 type ) const
{
INT64 totalDataPages = 0 ;
const dmsStorageUnitHeader *dataHeader = NULL ;
PD_TRACE_ENTRY ( SDB__DMSSU_TOTALDATAPAGES ) ;
if ( !_pDataSu || !_pIndexSu || !_pLobSu )
{
goto done ;
}
if ( type & DMS_SU_DATA )
{
dataHeader = _pDataSu->getHeader() ;
totalDataPages += dataHeader->_pageNum ;
}
if ( type & DMS_SU_INDEX )
{
dataHeader = _pIndexSu->getHeader() ;
totalDataPages += dataHeader->_pageNum ;
}
if ( ( type & DMS_SU_LOB ) && _pLobSu->isOpened() )
{
totalDataPages += _pLobSu->getHeader()->_pageNum ;
}
done:
PD_TRACE1 ( SDB__DMSSU_TOTALDATAPAGES,
PD_PACK_LONG ( totalDataPages ) ) ;
PD_TRACE_EXIT ( SDB__DMSSU_TOTALDATAPAGES ) ;
return totalDataPages ;
}
