// PD_TRACE_DECLARE_FUNCTION ( SDB_NETMLTRTAGT_HNDMSG, "netMultiRouteAgent::handleMsg" )
INT32 netMultiRouteAgent::handleMsg( const NET_HANDLE &handle,
const _MsgHeader *header,
const CHAR *msg )
{
INT32 rc = SDB_OK;
PD_TRACE_ENTRY ( SDB_NETMLTRTAGT_HNDMSG );
CHAR *pMsgRsp = (CHAR *)SDB_OSS_MALLOC( header->messageLength );
PD_CHECK( pMsgRsp, SDB_OOM, error, PDERROR,
"Memory malloc failed(size = %d)", header->messageLength ) ;
ossMemcpy( pMsgRsp, msg, header->messageLength );
{
ossScopedLock _lock( &_mutex, SHARED ) ;
COORD_SESSION_MAP::iterator it = _sessionMap.find( header->TID );
if ( _sessionMap.end() != it )
{
it->second->postEvent( pmdEDUEvent( PMD_EDU_EVENT_MSG,
PMD_EDU_MEM_ALLOC,
pMsgRsp ) ) ;
}
else
{
PD_LOG( PDWARNING, "Recieve expired msg[opCode:[%d]%d, TID:%d,"
"ReqID:%lld] from node[%d:%d:%d]",
IS_REPLY_TYPE( header->opCode ),
GET_REQUEST_TYPE( header->opCode ), header->TID,
header->requestID, header->routeID.columns.groupID,
header->routeID.columns.nodeID,
header->routeID.columns.serviceID ) ;
rc = SDB_SYS ;
goto error ;
}
}
done:
PD_TRACE_EXITRC ( SDB_NETMLTRTAGT_HNDMSG, rc );
return rc ;
error:
if ( pMsgRsp )
{
SDB_OSS_FREE( pMsgRsp ) ;
}
goto done ;
}
INT32 _sptClassMetaInfo::_getContents( const CHAR *pFileBuff,
const CHAR *pMark1,
const CHAR*pMark2,
CHAR **ppBuff,
INT32 *pBuffSize )
{
INT32 rc = SDB_OK ;
stringstream ss ;
INT32 buffSize = 0 ;
CHAR *pBuff = NULL ;
CHAR *begin = NULL ;
CHAR *end = NULL ;
begin = ossStrstr( (CHAR *)pFileBuff, (CHAR *)pMark1 ) ;
end = ossStrstr( (CHAR *)pFileBuff, (CHAR *)pMark2 ) ;
if ( NULL == begin || NULL == end )
{
rc = SDB_INVALIDARG ;
ss << "Failed to get [" << pMark1 << "], or ["
<< pMark2 << "], rc = " << rc << ERROR_END ;
goto error ;
}
buffSize = end - begin ;
pBuff = (CHAR *)SDB_OSS_MALLOC( buffSize + 1 ) ;
if ( NULL == pBuff )
{
rc = SDB_OOM ;
ss << "Failed to alloc [" << buffSize << "] bytes, rc = "
<< rc << ERROR_END ;
goto error ;
}
ossMemset( pBuff, 0, buffSize ) ;
ossMemcpy( pBuff, begin, buffSize ) ;
pBuff[buffSize] = '\0' ;
*ppBuff = pBuff ;
*pBuffSize = buffSize + 1 ;
done:
return rc ;
error:
PRINT_ERROR ;
goto done ;
}
void _rtnLobWindow::cacheLastDataOrClearCache()
{
if ( _pageSize == _cachedSz )
{
_cachedSz = 0 ;
}
if ( !_writeData.empty() )
{
SDB_ASSERT( _writeData.tuple.columns.len < ( UINT32 )_pageSize, "impossible" ) ;
SDB_ASSERT( 0 == _cachedSz || _cachedSz == _pageSize, "impossible" ) ;
ossMemcpy( _pool, _writeData.data, _writeData.tuple.columns.len ) ;
_cachedSz += _writeData.tuple.columns.len ;
_writeData.clear() ;
}
_analysisCache = FALSE ;
return ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__PARSE, "_dpsReplicaLogMgr::_parse" )
INT32 _dpsReplicaLogMgr::_parse( UINT32 sub, UINT32 offset,
UINT32 len, CHAR *out )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__PARSE );
UINT32 localSub = sub;
UINT32 localOffset = offset;
UINT32 needParseLen = len;
UINT32 outOffset = 0;
SDB_ASSERT ( out, "out can't be NULL" ) ;
if ( offset + len >= _pageNum*DPS_DEFAULT_PAGE_SIZE )
{
PD_LOG ( PDERROR, "offset + len is greater than buffer size, "
"offset = %d, len = %d", offset, len ) ;
rc = SDB_DPS_CORRUPTED_LOG ;
goto error ;
}
while ( needParseLen > 0 )
{
UINT32 parseLen = ( DPS_DEFAULT_PAGE_SIZE - localOffset ) <
needParseLen ?
( DPS_DEFAULT_PAGE_SIZE - localOffset ) :
needParseLen;
ossMemcpy( out + outOffset,
(PAGE( localSub )->mb())->offset( localOffset ), parseLen );
localOffset += parseLen;
outOffset += parseLen;
needParseLen -= parseLen;
if ( 0 == ( DPS_DEFAULT_PAGE_SIZE - localOffset ) )
{
localSub = _incPageID( localSub ) ;
localOffset = 0 ;
}
}
done :
PD_TRACE_EXITRC ( SDB__DPSRPCMGR__PARSE, rc );
return rc ;
error :
goto done ;
}
INT32 utilStrJoin( const CHAR **src,
UINT32 cnt,
CHAR *join,
UINT32 &joinSize )
{
SDB_ASSERT( NULL != join, "impossible" ) ;
INT32 rc = SDB_OK ;
UINT32 len = 0 ;
for ( UINT32 i = 0; i < cnt; i++ )
{
if ( NULL != src[i] )
{
UINT32 sLen = ossStrlen(src[i]) ;
ossMemcpy( join + len, src[i], sLen ) ;
len += sLen ;
}
}
joinSize = len ;
return rc ;
}
INT32 _rtnObjBuff::getOwned()
{
INT32 rc = SDB_OK ;
if ( !_owned && _pBuff )
{
CHAR *pBuff = ( CHAR* )SDB_OSS_MALLOC( _buffSize ) ;
if ( pBuff )
{
ossMemcpy( pBuff, _pBuff, _buffSize ) ;
_pBuff = pBuff ;
_owned = TRUE ;
}
else
{
rc = SDB_OOM ;
}
}
return rc ;
}
INT32 resize( UINT32 size )
{
INT32 rc = SDB_OK ;
if ( size <= _bufSize ||
size <= _eleSize )
{
goto done ;
}
else if ( UTIL_ARRAY_DEFAULT_SIZE == _bufSize )
{
_dynamicBuf = ( T * )SDB_OSS_MALLOC( sizeof( T ) * size ) ;
if ( NULL == _dynamicBuf )
{
rc = SDB_OOM ;
goto error ;
}
_bufSize = size ;
ossMemcpy( _dynamicBuf, _staticBuf, sizeof( T ) * UTIL_ARRAY_DEFAULT_SIZE ) ;
_eles = _dynamicBuf ;
}
else
{
T *tmp = _dynamicBuf ;
_dynamicBuf = ( T * )SDB_OSS_REALLOC( _dynamicBuf,
sizeof( T ) * size ) ;
if ( NULL == _dynamicBuf )
{
_dynamicBuf = tmp ;
rc = SDB_OOM ;
goto error ;
}
_bufSize = size ;
_eles = _dynamicBuf ;
}
done:
return rc ;
error:
goto done ;
}
OSS_INLINE INT32 append( const T &t )
{
INT32 rc = SDB_OK ;
if ( _eleSize < _bufSize )
{
_eles[_eleSize++] = t ;
}
else if ( UTIL_ARRAY_DEFAULT_SIZE == _bufSize )
{
_dynamicBuf = ( T * )SDB_OSS_MALLOC( sizeof( T ) * ( _bufSize * 2 ) ) ;
if ( NULL == _dynamicBuf )
{
rc = SDB_OOM ;
goto error ;
}
_bufSize *= 2 ;
ossMemcpy( _dynamicBuf, _staticBuf, sizeof( T ) * UTIL_ARRAY_DEFAULT_SIZE ) ;
_eles = _dynamicBuf ;
_eles[_eleSize++] = t ;
}
else
{
T *tmp = _dynamicBuf ;
_dynamicBuf = ( T * )SDB_OSS_REALLOC( _dynamicBuf,
sizeof( T ) * _bufSize * 2 ) ;
if ( NULL == _dynamicBuf )
{
_dynamicBuf = tmp ;
rc = SDB_OOM ;
goto error ;
}
_bufSize *= 2 ;
_eles = _dynamicBuf ;
_eles[_eleSize++] = t ;
}
done:
return rc ;
error:
goto done ;
}
INT32 _dpsLogPage::fill( UINT32 offset, const CHAR *src, UINT32 len )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSLGPAGE );
if ( !_mb )
{
_mb = SDB_OSS_NEW _dpsMessageBlock( DPS_DEFAULT_PAGE_SIZE );
if ( NULL == _mb )
{
pdLog(PDERROR, __FUNC__, __FILE__, __LINE__,
"new _dpsMessageBlock failed!");
rc = SDB_OOM ;
goto error ;
}
}
ossMemcpy ( _mb->offset( offset ), src, len ) ;
done :
PD_TRACE_EXITRC ( SDB__DPSLGPAGE, rc );
return rc ;
error :
goto done ;
}
INT32 getProgramPath( CHAR *pOutputPath )
{
INT32 rc = SDB_OK ;
CHAR *t = OSS_FILE_SEP ;
const CHAR *p = NULL ;
if ( !pOutputPath )
{
rc = SDB_INVALIDARG ;
goto error ;
}
if ( progName[0] == '\0' )
{
pOutputPath[0] = '\0' ;
goto done ;
}
p = ossStrrchr ( progName, t[0] ) ;
if ( p )
{
INT32 pathLen = p - progName + 1 ;
if ( pathLen > OSS_MAX_PATHSIZE + 1 )
{
pOutputPath[0] = '\0' ;
rc = SDB_INVALIDARG ;
goto error ;
}
ossMemcpy ( pOutputPath, progName, pathLen ) ;
pOutputPath[pathLen] = '\0' ;
}
else
{
pOutputPath[0] = '\0' ;
}
done :
return rc ;
error :
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_RECDROW, "_dpsLogWrapper::recordRow" )
INT32 _dpsLogWrapper::recordRow( const CHAR *row, UINT32 len )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_RECDROW );
if ( !_initialized )
{
goto done;
}
{
SDB_ASSERT( NULL != row, "row should not be NULL!") ;
_dpsMergeBlock block ;
dpsLogRecord &record = block.record();
dpsLogRecordHeader &header = record.head() ;
ossMemcpy( &header, row, sizeof(dpsLogRecordHeader) );
block.setRow( TRUE ) ;
rc = record.push( DPS_LOG_ROW_ROWDATA,
header._length - sizeof(dpsLogRecordHeader),
row + sizeof(dpsLogRecordHeader)) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to push row to record:%d", rc ) ;
goto error;
}
_lastWriteTick = pmdGetDBTick() ;
++_writeReordNum ;
rc = _buf.merge( block );
}
done :
PD_TRACE_EXITRC ( SDB__DPSLGWRAPP_RECDROW, rc );
return rc ;
error:
goto done ;
}
INT32 restAdaptor::recvRequestBody( pmdRestSession *pSession,
HTTP_PARSE_COMMON &common,
CHAR **ppPath,
INT32 &pathSize )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY( SDB__RESTADP_RECVREQBO ) ;
SDB_ASSERT ( pSession, "pSession is NULL" ) ;
SDB_ASSERT ( ppPath, "ppPath is NULL" ) ;
httpConnection *pHttpCon = pSession->getRestConn() ;
CHAR *pBuffer = NULL ;
const CHAR *pContentLength = NULL ;
CHAR *pUrl = NULL ;
INT32 bodySize = 0 ;
INT32 sumBodySize = 0 ;
INT32 curRecvSize = 0 ;
INT32 receivedSize = 0 ;
INT32 tempSize = 0 ;
INT32 urlSize = 0 ;
rc = getHttpHeader( pSession, REST_STRING_CONLEN, &pContentLength ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to get http header, rc=%d", rc ) ;
goto error ;
}
if ( pContentLength )
{
bodySize = ossAtoi( pContentLength ) ;
if ( bodySize > 0 )
{
if ( bodySize > _maxHttpBodySize )
{
rc = SDB_REST_RECV_SIZE ;
PD_LOG ( PDERROR, "http body size %d greater than %d",
bodySize,
_maxHttpBodySize ) ;
goto error ;
}
rc = pSession->allocBuff( bodySize + 1,
&(pHttpCon->_pBodyBuf),
sumBodySize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
bodySize, rc ) ;
goto error ;
}
pBuffer = pHttpCon->_pBodyBuf ;
pBuffer[bodySize] = 0 ;
if ( pHttpCon->_pPartBody )
{
ossMemcpy( pHttpCon->_pBodyBuf,
pHttpCon->_pPartBody,
pHttpCon->_partSize ) ;
receivedSize = pHttpCon->_partSize ;
}
rc = pSession->recvData( pBuffer + receivedSize,
bodySize - receivedSize,
_timeout,
TRUE,
&curRecvSize,
0 ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to recv, rc=%d", rc ) ;
goto error ;
}
receivedSize += curRecvSize ;
urlSize = urlDecodeSize( pBuffer, receivedSize ) ;
rc = pSession->allocBuff( urlSize + 1, &pUrl, tempSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
urlSize + 1, rc ) ;
goto error ;
}
urlDecode( pBuffer, receivedSize,
&pUrl, urlSize ) ;
pUrl[ urlSize ] = 0 ;
_parse_http_query( pHttpCon, pUrl, urlSize ) ;
}
}
rc = _convertMsg( pSession, common, ppPath, pathSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to build msg, rc=%d", rc ) ;
goto error ;
}
pHttpCon->_common = common ;
done:
PD_TRACE_EXITRC( SDB__RESTADP_RECVREQBO, rc ) ;
return rc ;
error:
goto done ;
}
INT32 restAdaptor::_convertMsg( pmdRestSession *pSession,
HTTP_PARSE_COMMON &common,
CHAR **ppMsg,
INT32 &msgSize )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY( SDB__RESTADP_CONVERTMSG );
SDB_ASSERT ( pSession, "pSession is NULL" ) ;
SDB_ASSERT ( ppMsg, "pMsg is NULL" ) ;
INT32 pathSize = 0 ;
INT32 tempSize = 0 ;
INT32 extenSize = 0 ;
const CHAR *pFileName = NULL ;
const CHAR *pExtension = NULL ;
CHAR *pMsg = NULL ;
httpConnection *pHttpCon = pSession->getRestConn() ;
pFileName = _getResourceFileName( pHttpCon->_pPath ) ;
if ( pFileName )
{
common = COM_GETFILE ;
pHttpCon->_fileType = HTTP_FILE_UNKNOW ;
pExtension = _getFileExtension( pFileName ) ;
if ( pExtension )
{
extenSize = ossStrlen( pExtension ) ;
for( UINT32 i = 0; i < REST_STRING_FILE_EX_SIZE; ++i )
{
if ( 0 == ossStrncasecmp( pExtension,
fileExtension[i], extenSize ) )
{
pHttpCon->_fileType = (HTTP_FILE_TYPE)i ;
break ;
}
}
}
}
else
{
if ( pHttpCon->_requestQuery.size() > 0 )
{
common = COM_CMD ;
pHttpCon->_fileType = HTTP_FILE_HTML ;
}
else
{
common = COM_GETFILE ;
pHttpCon->_fileType = HTTP_FILE_DEFAULT ;
}
}
pathSize = ossStrlen( pHttpCon->_pPath ) ;
rc = pSession->allocBuff( pathSize, &pMsg, tempSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
pathSize, rc ) ;
goto error ;
}
ossMemcpy( pMsg, pHttpCon->_pPath, pathSize ) ;
pMsg[pathSize] = 0 ;
*ppMsg = pMsg ;
msgSize = pathSize ;
done:
PD_TRACE_EXITRC ( SDB__RESTADP_CONVERTMSG, rc ) ;
return rc ;
error:
goto done ;
}
INT32 restAdaptor::appendHttpBody( pmdRestSession *pSession,
const CHAR *pBuffer,
INT32 length,
INT32 number, BOOLEAN isObjBuffer )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY( SDB__RESTADP_APPENDBODY ) ;
SDB_ASSERT ( pSession, "pSession is NULL" ) ;
SDB_ASSERT ( pBuffer, "pBuffer is NULL" ) ;
httpConnection *pHttpCon = pSession->getRestConn() ;
INT32 tempSize = 0 ;
httpResponse httpRe ;
if( TRUE == pHttpCon->_isChunk )
{
if( FALSE == pHttpCon->_isSendHttpHeader )
{
pHttpCon->_isSendHttpHeader = TRUE ;
rc = _setResponseType( pSession ) ;
if( rc )
{
PD_LOG ( PDERROR, "Failed to set respone type, rc=%d",
rc ) ;
goto error ;
}
rc = _sendHttpHeader( pSession, HTTP_OK ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to send http header, rc=%d", rc ) ;
goto error ;
}
}
if( isObjBuffer )
{
INT32 jsonSize = 0 ;
BSONObj record ;
std::string str ;
_rtnObjBuff rtnObj( pBuffer, length, number ) ;
while( TRUE )
{
rc = rtnObj.nextObj( record ) ;
if ( SDB_DMS_EOC == rc )
{
rc = SDB_OK ;
break ;
}
else if ( SDB_SYS == rc )
{
PD_LOG ( PDERROR, "Failed to get nextObj:rc=%d", rc ) ;
goto error ;
}
str = record.toString( FALSE, TRUE ) ;
jsonSize = ossStrlen( str.c_str() ) ;
rc = _sendHttpChunk( pSession, str.c_str(), jsonSize ) ;
if( rc )
{
PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
goto error ;
}
}
}
else
{
rc = _sendHttpChunk( pSession, pBuffer, length ) ;
if( rc )
{
PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
goto error ;
}
}
}
else
{
if( isObjBuffer )
{
CHAR *pJson = NULL ;
INT32 jsonSize = 0 ;
BSONObj record ;
std::string str ;
_rtnObjBuff rtnObj( pBuffer, length, number ) ;
while( TRUE )
{
rc = rtnObj.nextObj( record ) ;
if ( SDB_DMS_EOC == rc )
{
rc = SDB_OK ;
break ;
}
else if ( SDB_SYS == rc )
{
PD_LOG ( PDERROR, "Failed to get nextObj:rc=%d", rc ) ;
goto error ;
}
str = record.toString( FALSE, TRUE ) ;
jsonSize = ossStrlen( str.c_str() ) ;
rc = pSession->allocBuff( jsonSize + 1, &pJson, tempSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
jsonSize + 1, rc ) ;
goto error ;
}
ossMemcpy( pJson, str.c_str(), jsonSize ) ;
pJson[ jsonSize ] = 0 ;
pHttpCon->_responseSize += jsonSize ;
httpRe.pBuffer = pJson ;
httpRe.len = jsonSize ;
pHttpCon->_responseBody.push_back( httpRe ) ;
pBuffer = NULL ;
jsonSize = 0 ;
}
}
else
{
CHAR *pFileText = NULL ;
rc = pSession->allocBuff( length + 1, &pFileText, tempSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
length + 1, rc ) ;
goto error ;
}
ossMemcpy( pFileText, pBuffer, length ) ;
pFileText[ length ] = 0 ;
pHttpCon->_firstRecordSize = length ;
httpRe.pBuffer = pFileText ;
httpRe.len = length ;
pHttpCon->_responseBody[0] = httpRe ;
}
}
done:
PD_TRACE_EXITRC( SDB__RESTADP_APPENDBODY, rc ) ;
return rc ;
error:
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGFILEMGR_LOAD, "_dpsLogFileMgr::load" )
INT32 _dpsLogFileMgr::load( const DPS_LSN &lsn, _dpsMessageBlock *mb,
BOOLEAN onlyHeader,
UINT32 *pLength )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSLGFILEMGR_LOAD );
SDB_ASSERT ( mb, "mb can't be NULL" ) ;
UINT32 sub = ( UINT32 )( lsn.offset / _logFileSz % _files.size() ) ;
dpsLogRecordHeader head ;
UINT32 len = 0 ;
rc = LOG_FILE( sub )->read( lsn.offset, sizeof(dpsLogRecordHeader),
(CHAR*)&head ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to read log file %d, rc = %d", sub, rc ) ;
goto error ;
}
if ( lsn.offset != head._lsn )
{
PD_LOG ( PDERROR, "Invalid LSN is read from log file, expect %lld, %d,"
"actual %lld, %d", lsn.offset, lsn.version, head._lsn,
head._version ) ;
rc = SDB_DPS_LOG_NOT_IN_FILE ;
goto error ;
}
if ( head._length < sizeof(dpsLogRecordHeader) )
{
PD_LOG ( PDERROR, "LSN length[%u] is smaller than dps log head",
head._length ) ;
rc = SDB_DPS_CORRUPTED_LOG ;
goto error ;
}
if ( pLength )
{
*pLength = head._length ;
}
if ( onlyHeader )
{
len = sizeof( dpsLogRecordHeader ) ;
}
else
{
len = head._length ;
}
if ( mb->idleSize() < len )
{
rc = mb->extend ( len - mb->idleSize() ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to extend mb, rc = %d", rc ) ;
goto error ;
}
}
ossMemcpy( mb->writePtr(), &head, sizeof(dpsLogRecordHeader ) ) ;
mb->writePtr( mb->length() + sizeof( dpsLogRecordHeader ) ) ;
if ( onlyHeader )
{
goto done ;
}
rc = LOG_FILE( sub )->read ( lsn.offset + sizeof(dpsLogRecordHeader ),
head._length - sizeof( dpsLogRecordHeader ),
mb->writePtr() ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to read from log file %d for %d bytes, "
"rc = %d", sub, head._length-sizeof(dpsLogRecordHeader),
rc ) ;
mb->writePtr( mb->length() - sizeof( dpsLogRecordHeader ) ) ;
goto error ;
}
mb->writePtr ( mb->length() + head._length -
sizeof( dpsLogRecordHeader ) ) ;
done:
PD_TRACE_EXITRC ( SDB__DPSLGFILEMGR_LOAD, rc ) ;
return rc ;
error:
goto done ;
}
INT32 _coordDeleteOperator::_prepareMainCLOp( coordCataSel &cataSel,
coordSendMsgIn &inMsg,
coordSendOptions &options,
pmdEDUCB *cb,
coordProcessResult &result )
{
INT32 rc = SDB_OK ;
MsgOpDelete *pDelMsg = ( MsgOpDelete* )inMsg.msg() ;
INT32 flag = 0 ;
CHAR *pCollectionName = NULL;
CHAR *pDeletor = NULL;
CHAR *pHint = NULL;
CoordGroupSubCLMap &grpSubCl = cataSel.getGroup2SubsMap() ;
CoordGroupSubCLMap::iterator it ;
inMsg.data()->clear() ;
rc = msgExtractDelete( (CHAR*)inMsg.msg(), &flag, &pCollectionName,
&pDeletor, &pHint ) ;
PD_RC_CHECK( rc, PDERROR, "Failed to parse delete request, rc: %d",
rc ) ;
try
{
BSONObj boDeletor( pDeletor ) ;
BSONObj boHint( pHint ) ;
BSONObj boNew ;
CHAR *pBuff = NULL ;
UINT32 buffLen = 0 ;
UINT32 buffPos = 0 ;
it = grpSubCl.begin() ;
while( it != grpSubCl.end() )
{
CoordSubCLlist &subCLLst = it->second ;
netIOVec &iovec = inMsg._datas[ it->first ] ;
netIOV ioItem ;
ioItem.iovBase = (const CHAR*)inMsg.msg() + sizeof( MsgHeader ) ;
ioItem.iovLen = ossRoundUpToMultipleX ( offsetof(MsgOpDelete, name) +
pDelMsg->nameLength + 1, 4 ) -
sizeof( MsgHeader ) ;
iovec.push_back( ioItem ) ;
boNew = _buildNewDeletor( boDeletor, subCLLst ) ;
UINT32 roundLen = ossRoundUpToMultipleX( boNew.objsize(), 4 ) ;
if ( buffPos + roundLen > buffLen )
{
UINT32 alignLen = ossRoundUpToMultipleX( roundLen,
DMS_PAGE_SIZE4K ) ;
rc = cb->allocBuff( alignLen, &pBuff, &buffLen ) ;
PD_RC_CHECK( rc, PDERROR, "Alloc buff[%u] failed, rc: %d",
alignLen, rc ) ;
_vecBlock.push_back( pBuff ) ;
buffPos = 0 ;
}
ossMemcpy( &pBuff[ buffPos ], boNew.objdata(), boNew.objsize() ) ;
ioItem.iovBase = &pBuff[ buffPos ] ;
ioItem.iovLen = roundLen ;
buffPos += roundLen ;
iovec.push_back( ioItem ) ;
ioItem.iovBase = boHint.objdata() ;
ioItem.iovLen = boHint.objsize() ;
iovec.push_back( ioItem ) ;
++it ;
}
}
catch( std::exception &e )
{
PD_LOG( PDERROR, "Parse delete message occur exception: %s",
e.what() ) ;
rc = SDB_SYS ;
goto error ;
}
done:
return rc ;
error:
_clearBlock( cb ) ;
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_OSSWKSEX, "ossWalkStackEx" )
UINT32 ossWalkStackEx( LPEXCEPTION_POINTERS lpEP,
UINT32 framesToSkip,
UINT32 framesRequested ,
void ** ppInstruction )
{
PD_TRACE_ENTRY ( SDB_OSSWKSEX );
HANDLE hProcess = GetCurrentProcess() ;
HANDLE hThread = GetCurrentThread() ;
STACKFRAME64 stackFrame = { 0 } ;
CONTEXT cContext = { 0 } ;
PCONTEXT pContext = &cContext ;
BOOLEAN bSuccess = true ;
UINT32 numFrames, framesOnStk ;
framesOnStk = 0 ;
if ( NULL != ppInstruction )
{
numFrames = framesRequested ;
if ( OSS_MAX_BACKTRACE_FRAMES_SUPPORTED <= ( framesToSkip + numFrames ) )
{
numFrames = OSS_MAX_BACKTRACE_FRAMES_SUPPORTED - framesToSkip -1 ;
}
if ( NULL == lpEP )
{
framesOnStk = CaptureStackBackTrace( framesToSkip,
numFrames, ppInstruction, NULL ) ;
}
else
{
#ifndef _WIN64
stackFrame.AddrPC.Offset = lpEP->ContextRecord->Eip ;
stackFrame.AddrPC.Mode = AddrModeFlat ;
stackFrame.AddrStack.Offset = lpEP->ContextRecord->Esp ;
stackFrame.AddrStack.Mode = AddrModeFlat ;
stackFrame.AddrFrame.Offset = lpEP->ContextRecord->Ebp ;
stackFrame.AddrFrame.Mode = AddrModeFlat ;
ossMemcpy( pContext, lpEP->ContextRecord, sizeof( CONTEXT ) ) ;
#else
RtlCaptureContext( pContext ) ;
#endif
bSuccess = true ;
WaitForSingleObject( ossGetSysMutexHandle( _StackWalk64 ), INFINITE ) ;
while ( bSuccess && framesOnStk < numFrames )
{
bSuccess = StackWalk64( OSS_THIS_IMAGE_MACHINE_TYPE,
hProcess,
hThread,
&stackFrame,
pContext,
NULL,
SymFunctionTableAccess64,
SymGetModuleBase64,
NULL ) ;
if ( bSuccess )
{
ppInstruction[ framesOnStk ] = (void*)stackFrame.AddrPC.Offset ;
}
else
{
ppInstruction[ framesOnStk ] = 0 ;
}
framesOnStk++ ;
}
ReleaseMutex ( ossGetSysMutexHandle( _StackWalk64 ) ) ;
}
}
PD_TRACE_EXIT ( SDB_OSSWKSEX );
return framesOnStk ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSSTORAGELOADEXT__IMPRTBLOCK, "dmsStorageLoadOp::pushToTempDataBlock" )
INT32 dmsStorageLoadOp::pushToTempDataBlock ( dmsMBContext *mbContext,
pmdEDUCB *cb,
BSONObj &record,
BOOLEAN isLast,
BOOLEAN isAsynchr )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DMSSTORAGELOADEXT__IMPRTBLOCK );
UINT32 dmsrecordSize = 0 ;
dmsRecord *pRecord = NULL ;
dmsRecord *pPreRecord = NULL ;
dmsOffset offset = DMS_INVALID_OFFSET ;
dmsOffset recordOffset = DMS_INVALID_OFFSET ;
_IDToInsert oid ;
idToInsertEle oidEle((CHAR*)(&oid)) ;
CHAR *pNewRecordData = NULL ;
dmsRecordData recordData ;
dmsCompressorEntry *compressorEntry = NULL ;
SDB_ASSERT( mbContext, "mb context can't be NULL" ) ;
compressorEntry = _su->data()->getCompressorEntry( mbContext->mbID() ) ;
/* For concurrency protection with drop CL and set compresor. */
dmsCompressorGuard compGuard( compressorEntry, SHARED ) ;
try
{
recordData.setData( record.objdata(), record.objsize(),
FALSE, TRUE ) ;
/* (0) */
BSONElement ele = record.getField ( DMS_ID_KEY_NAME ) ;
const CHAR *pCheckErr = "" ;
if ( !dmsIsRecordIDValid( ele, TRUE, &pCheckErr ) )
{
PD_LOG( PDERROR, "Record[%s] _id is error: %s",
record.toString().c_str(), pCheckErr ) ;
rc = SDB_INVALIDARG ;
goto error ;
}
if ( ele.eoo() )
{
oid._oid.init() ;
rc = cb->allocBuff( oidEle.size() + record.objsize(),
&pNewRecordData ) ;
if ( rc )
{
PD_LOG( PDERROR, "Alloc memory[size:%u] failed, rc: %d",
oidEle.size() + record.objsize(), rc ) ;
goto error ;
}
*(UINT32*)pNewRecordData = oidEle.size() + record.objsize() ;
ossMemcpy( pNewRecordData + sizeof(UINT32), oidEle.rawdata(),
oidEle.size() ) ;
ossMemcpy( pNewRecordData + sizeof(UINT32) + oidEle.size(),
record.objdata() + sizeof(UINT32),
record.objsize() - sizeof(UINT32) ) ;
recordData.setData( pNewRecordData,
oidEle.size() + record.objsize(),
FALSE, TRUE ) ;
record = BSONObj( pNewRecordData ) ;
}
dmsrecordSize = recordData.len() ;
if ( recordData.len() + DMS_RECORD_METADATA_SZ >
DMS_RECORD_USER_MAX_SZ )
{
rc = SDB_DMS_RECORD_TOO_BIG ;
goto error ;
}
if ( compressorEntry->ready() )
{
const CHAR *compressedData = NULL ;
INT32 compressedDataSize = 0 ;
UINT8 compressRatio = 0 ;
rc = dmsCompress( cb, compressorEntry,
recordData.data(), recordData.len(),
&compressedData, &compressedDataSize,
compressRatio ) ;
if ( SDB_OK == rc &&
compressedDataSize + sizeof(UINT32) < recordData.orgLen() &&
compressRatio < DMS_COMPRESS_RATIO_THRESHOLD )
{
dmsrecordSize = compressedDataSize + sizeof(UINT32) ;
recordData.setData( compressedData, compressedDataSize,
TRUE, FALSE ) ;
}
else if ( rc )
{
if ( SDB_UTIL_COMPRESS_ABORT == rc )
{
PD_LOG( PDINFO, "Record compression aborted. "
"Insert the original data. rc: %d", rc ) ;
}
else
{
PD_LOG( PDWARNING, "Record compression failed. "
"Insert the original data. rc: %d", rc ) ;
}
rc = SDB_OK ;
}
}
/*
* Release the guard to avoid deadlock with truncate/drop collection.
*/
compGuard.release() ;
dmsrecordSize *= DMS_RECORD_OVERFLOW_RATIO ;
dmsrecordSize += DMS_RECORD_METADATA_SZ ;
dmsrecordSize = OSS_MIN( DMS_RECORD_MAX_SZ,
ossAlignX ( dmsrecordSize, 4 ) ) ;
INT32 expandSize = dmsrecordSize << DMS_RECORDS_PER_EXTENT_SQUARE ;
if ( expandSize > DMS_BEST_UP_EXTENT_SZ )
{
expandSize = expandSize < DMS_BEST_UP_EXTENT_SZ ?
DMS_BEST_UP_EXTENT_SZ : expandSize ;
}
if ( !_pCurrentExtent )
{
rc = _allocateExtent ( expandSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to allocate new extent in reorg file, "
"rc = %d", rc ) ;
goto error ;
}
_currentExtent = (dmsExtent*)_pCurrentExtent ;
}
if ( dmsrecordSize > (UINT32)_currentExtent->_freeSpace || isLast )
{
rc = mbContext->mbLock( EXCLUSIVE ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to lock collection, rc=%d", rc ) ;
goto error ;
}
if ( !isAsynchr )
{
_currentExtent->_firstRecordOffset = DMS_INVALID_OFFSET ;
_currentExtent->_lastRecordOffset = DMS_INVALID_OFFSET ;
}
rc = _su->loadExtentA( mbContext, _pCurrentExtent,
_currentExtentSize / _pageSize,
TRUE ) ;
mbContext->mbUnlock() ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to load extent, rc = %d", rc ) ;
goto error ;
}
if ( isLast )
{
goto done ;
}
rc = _allocateExtent ( expandSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to allocate new extent in reorg file, "
"rc = %d", rc ) ;
goto error ;
}
}
recordOffset = _currentExtentSize - _currentExtent->_freeSpace ;
pRecord = ( dmsRecord* )( (const CHAR*)_currentExtent + recordOffset ) ;
if ( _currentExtent->_freeSpace - (INT32)dmsrecordSize <
(INT32)DMS_MIN_RECORD_SZ &&
_currentExtent->_freeSpace <= (INT32)DMS_RECORD_MAX_SZ )
{
dmsrecordSize = _currentExtent->_freeSpace ;
}
pRecord->setNormal() ;
pRecord->setMyOffset( recordOffset ) ;
pRecord->setSize( dmsrecordSize ) ;
pRecord->setData( recordData ) ;
pRecord->setNextOffset( DMS_INVALID_OFFSET ) ;
pRecord->setPrevOffset( DMS_INVALID_OFFSET ) ;
if ( isAsynchr )
{
_currentExtent->_recCount++ ;
}
_currentExtent->_freeSpace -= dmsrecordSize ;
offset = _currentExtent->_lastRecordOffset ;
if ( DMS_INVALID_OFFSET != offset )
{
pPreRecord = (dmsRecord*)( (const CHAR*)_currentExtent + offset ) ;
pPreRecord->setNextOffset( recordOffset ) ;
pRecord->setPrevOffset( offset ) ;
}
_currentExtent->_lastRecordOffset = recordOffset ;
offset = _currentExtent->_firstRecordOffset ;
if ( DMS_INVALID_OFFSET == offset )
{
_currentExtent->_firstRecordOffset = recordOffset ;
}
}
catch( std::exception &e )
{
PD_LOG( PDERROR, "Occur exception: %s", e.what() ) ;
rc = SDB_SYS ;
goto error ;
}
done:
PD_TRACE_EXITRC ( SDB__DMSSTORAGELOADEXT__IMPRTBLOCK, rc );
return rc ;
error:
goto done ;
}
INT32 _ossModuleHandle::patchModuleName( const CHAR* name, CHAR *patchedName, UINT32 size )
{
INT32 rc = SDB_OK ;
SDB_ASSERT( name, "Module name can not be NULL" ) ;
SDB_ASSERT( patchedName, "Patched buffer can not be NULL" ) ;
const CHAR *ptr = NULL ;
INT32 patchedNameLen = 0 ;
#ifdef _WINDOWS
INT32 tailLen = ossStrlen(LIB_END_STR) ;
#else
INT32 tailLen = ossStrlen(LIB_END_STR) ;
#endif
ossMemset( patchedName, 0, size ) ;
#ifdef _LINUX
ptr = ossStrstr( name, LIB_START_STR ) ;
if ( ptr != name )
{
ossMemcpy( patchedName, LIB_START_STR, ossStrlen(LIB_START_STR) ) ;
}
#endif
patchedNameLen = ossStrlen( patchedName ) ;
ptr = ossStrrchr( name, '.' ) ;
if ( ptr != NULL )
{
#ifdef _WINDOWS
if ( 'd' != *(ptr + 1) || 'l' != *(ptr + 2) && 'l' != *(ptr + 3) )
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ossStrlen( name ) ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
#else
if ( 's' != *(ptr + 1) && 'o' != *(ptr + 2) )
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ossStrlen( name ) ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
#endif
else
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, strlen( name ) ) ;
}
}
else
{
if ( patchedNameLen + ossStrlen( name ) + tailLen >= size )
{
rc = SDB_INVALIDSIZE ;
goto error ;
}
ossStrncat( patchedName, name, ptr - name ) ;
ossStrncat( patchedName, LIB_END_STR, tailLen ) ;
}
done:
return rc ;
error:
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__RESTRORE, "_dpsReplicaLogMgr::_restore" )
INT32 _dpsReplicaLogMgr::_restore ()
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__RESTRORE );
_dpsLogFile *file = _logger.getWorkLogFile() ;
DPS_LSN beginLsn = file->getFirstLSN ( FALSE ) ;
UINT32 length = file->getLength() ;
_dpsMessageBlock block ( sizeof ( dpsLogRecordHeader ) ) ;
_dpsMergeBlock mergeBlock ;
dpsLogRecordHeader &head = mergeBlock.record().head();
_restoreFlag = TRUE ;
if ( beginLsn.invalid() )
{
rc = SDB_DPS_INVALID_LSN ;
goto error ;
}
_movePages( beginLsn.offset, beginLsn.version ) ;
while ( beginLsn.offset % file->size() < length )
{
rc = _logger.load ( beginLsn, &block ) ;
if ( SDB_OK != rc )
{
PD_LOG ( PDERROR, "restore dps file load failed[rc:%d]", rc ) ;
goto error ;
}
ossMemcpy( &head, block.offset(0), sizeof(dpsLogRecordHeader) ) ;
mergeBlock.setRow( TRUE );
mergeBlock.record().push( DPS_LOG_ROW_ROWDATA,
block.length()- sizeof(dpsLogRecordHeader),
block.offset(sizeof(dpsLogRecordHeader))) ;
rc = merge ( mergeBlock ) ;
if ( SDB_OK != rc )
{
PD_LOG ( PDERROR, "restore merge failed[rc:%d]", rc ) ;
goto error ;
}
beginLsn.offset += head._length ;
mergeBlock.clear() ;
block.clear() ;
}
{
UINT32 fileIdleSize = file->getIdleSize() +
(&_pages[_work])->getLength() ;
if ( fileIdleSize % DPS_DEFAULT_PAGE_SIZE != 0 )
{
PD_LOG( PDERROR, "File[%s] idle size[%u] is not multi-times of "
"page size, cur page info[%u, %s]",
file->toString().c_str(), fileIdleSize,
_work, (&_pages[_work])->toString().c_str() ) ;
rc = SDB_SYS ;
SDB_ASSERT( FALSE, "Idle size error" ) ;
goto error ;
}
file->idleSize ( fileIdleSize ) ;
}
done:
_restoreFlag = FALSE ;
PD_TRACE_EXITRC ( SDB__DPSRPCMGR__RESTRORE, rc );
return rc ;
error:
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_RTNLOCALLOBSTREAM__QUERYLOBMETA, "_rtnLocalLobStream::_queryLobMeta" )
INT32 _rtnLocalLobStream::_queryLobMeta( _pmdEDUCB *cb,
_dmsLobMeta &meta,
BOOLEAN allowUncompleted,
_rtnLobPiecesInfo* piecesInfo )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY( SDB_RTNLOCALLOBSTREAM__QUERYLOBMETA ) ;
UINT32 len = _su->getLobPageSize() ;
UINT32 readLen = 0 ;
CHAR *buf = NULL ;
dmsLobRecord record ;
if ( SDB_LOB_MODE_WRITE == _getMode() )
{
rc = _queryLobMeta4Write( cb, meta, piecesInfo ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to query meta for write, rc: %d", rc ) ;
goto error ;
}
goto done ;
}
_getPool().clear() ;
rc = _getPool().allocate( len, &buf ) ;
if ( rc )
{
PD_LOG( PDERROR, "Failed to alloc buffer[%u], rc: %d",
len, rc ) ;
goto error ;
}
record.set( &getOID(), DMS_LOB_META_SEQUENCE, 0, len, NULL ) ;
rc = _su->lob()->read( record, _mbContext, cb, buf, readLen ) ;
if ( SDB_OK == rc )
{
if ( readLen < sizeof( _dmsLobMeta ) )
{
PD_LOG( PDERROR, "Read lob[%s]'s meta page len is less than "
"meta size[%u]", getOID().str().c_str(),
sizeof( _dmsLobMeta ) ) ;
rc = SDB_SYS ;
goto error ;
}
ossMemcpy( (void*)&meta, buf, sizeof( meta ) ) ;
if ( !meta.isDone() && !allowUncompleted )
{
PD_LOG( PDINFO, "Lob[%s] meta[%s] is not available",
getOID().str().c_str(), meta.toString().c_str() ) ;
rc = SDB_LOB_IS_NOT_AVAILABLE ;
goto error ;
}
if ( 0 == meta._modificationTime )
{
meta._modificationTime = meta._createTime ;
}
if ( meta._version >= DMS_LOB_META_MERGE_DATA_VERSION &&
meta._lobLen > 0 &&
readLen > DMS_LOB_META_LENGTH )
{
rc = _getPool().push( buf + DMS_LOB_META_LENGTH,
( meta._lobLen <= readLen-DMS_LOB_META_LENGTH ?
meta._lobLen : readLen-DMS_LOB_META_LENGTH ),
0 ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to push data to pool, rc:%d", rc ) ;
goto error ;
}
_getPool().pushDone() ;
}
if ( NULL != piecesInfo &&
meta.hasPiecesInfo() )
{
INT32 length = meta._piecesInfoNum * (INT32)sizeof( _rtnLobPieces ) ;
const CHAR* piecesInfoBuf = (const CHAR*)
( buf + DMS_LOB_META_LENGTH - length ) ;
rc = piecesInfo->readFrom( piecesInfoBuf, length ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to read pieces info from meta, rc:%d", rc ) ;
goto error ;
}
}
goto done ;
}
else
{
if ( SDB_LOB_SEQUENCE_NOT_EXIST == rc )
{
rc = SDB_FNE ;
}
else if ( SDB_FNE != rc )
{
PD_LOG( PDERROR, "Failed to get meta of lob, rc:%d", rc ) ;
}
goto error ;
}
done:
PD_TRACE_EXITRC( SDB_RTNLOCALLOBSTREAM__QUERYLOBMETA, rc ) ;
return rc ;
error:
goto done ;
}
void setDict( const CHAR *dict, UINT32 dictLen )
{
ossMemcpy((CHAR *)this + sizeof(_dmsDictExtent), dict, dictLen ) ;
_dictLen = dictLen ;
}
INT32 restAdaptor::setOPResult( pmdRestSession *pSession,
INT32 result,
const BSONObj &info )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY( SDB__RESTADP_SETOPR ) ;
SDB_ASSERT ( pSession, "pSession is NULL" ) ;
httpConnection *pHttpCon = pSession->getRestConn() ;
if( COM_GETFILE != pHttpCon->_common )
{
std::string str = info.toString( FALSE, TRUE ) ;
INT32 bufferSize = ossStrlen( str.c_str() ) ;
if( TRUE == pHttpCon->_isChunk )
{
if( FALSE == pHttpCon->_isSendHttpHeader )
{
pHttpCon->_isSendHttpHeader = TRUE ;
rc = _setResponseType( pSession ) ;
if( rc )
{
PD_LOG ( PDERROR, "Failed to set respone type, rc=%d",
rc ) ;
goto error ;
}
rc = _sendHttpHeader( pSession, HTTP_OK ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to send http header, rc=%d", rc ) ;
goto error ;
}
}
rc = _sendHttpChunk( pSession, str.c_str(), bufferSize ) ;
if( rc )
{
PD_LOG ( PDERROR, "Failed to send http chunk, rc=%d", rc ) ;
goto error ;
}
}
else
{
CHAR *pBuffer = NULL ;
INT32 tempSize = 0 ;
httpResponse httpRe ;
rc = pSession->allocBuff( bufferSize + 1, &pBuffer, tempSize ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Unable to allocate %d bytes memory, rc=%d",
bufferSize + 1, rc ) ;
goto error ;
}
ossMemcpy( pBuffer, str.c_str(), bufferSize ) ;
pBuffer[ bufferSize ] = 0 ;
pHttpCon->_firstRecordSize = bufferSize ;
httpRe.pBuffer = pBuffer ;
httpRe.len = bufferSize ;
pHttpCon->_responseBody[0] = httpRe ;
}
}
done:
PD_TRACE_EXITRC( SDB__RESTADP_SETOPR, rc ) ;
return rc ;
error:
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DMSROUNIT__INIT, "_dmsReorgUnit::_init" )
INT32 _dmsReorgUnit::_init ( BOOLEAN createNew )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DMSROUNIT__INIT );
class _reorgUnitHead *unitHead = NULL ;
INT32 bufSize = ossRoundUpToMultipleX (
sizeof ( class _reorgUnitHead ),
DMS_REORG_UNIT_HEAD_SIZE_UNIT ) ;
INT32 restSize = bufSize ;
_headSize = bufSize ;
CHAR *pBuffer = (CHAR*)SDB_OSS_MALLOC (bufSize) ;
if ( !pBuffer )
{
PD_LOG ( PDERROR, "Failed to allocate %d bytes of memory", bufSize ) ;
rc = SDB_OOM ;
goto error ;
}
unitHead = (class _reorgUnitHead*)pBuffer ;
ossMemset ( unitHead, 0, bufSize ) ;
if ( createNew )
{
SINT64 writeSize = 0 ;
_readOnly = FALSE ;
ossMemcpy ( unitHead->_eyeCatcher, DMS_REORG_UNIT_EYECATCHER,
DMS_REORG_UNIT_EYECATCHER_LEN ) ;
unitHead->_headerSize = bufSize ;
ossMemcpy ( unitHead->_fileName, _fileName, OSS_MAX_PATHSIZE ) ;
unitHead->_pageSize = _pageSize ;
while ( restSize != 0 )
{
rc = ossWrite ( &_file, &pBuffer[bufSize-restSize], restSize,
&writeSize ) ;
if ( rc && SDB_INTERRUPT != rc )
{
PD_LOG ( PDERROR, "Failed to write into file: %s, rc = %d",
_fileName, rc ) ;
goto error ;
}
restSize -= writeSize ;
rc = SDB_OK ;
}
}
else
{
SINT64 readSize = 0 ;
_readOnly = TRUE ;
while ( restSize > 0 )
{
rc = ossRead ( &_file, &pBuffer[bufSize-restSize], restSize, &readSize ) ;
if ( rc && SDB_INTERRUPT != rc )
{
PD_LOG ( PDERROR, "Failed to read from file: %s, rc = %d",
_fileName, rc ) ;
goto error ;
}
restSize -= readSize ;
rc = SDB_OK ;
}
if ( ossMemcmp ( unitHead->_eyeCatcher, DMS_REORG_UNIT_EYECATCHER,
DMS_REORG_UNIT_EYECATCHER_LEN ) ||
unitHead->_headerSize != bufSize )
{
PD_LOG ( PDERROR, "Invalid reorg file is detected" ) ;
rc = SDB_DMS_INVALID_REORG_FILE ;
goto error ;
}
}
done :
if ( pBuffer )
{
SDB_OSS_FREE ( pBuffer ) ;
}
PD_TRACE_EXITRC ( SDB__DMSROUNIT__INIT, rc );
return rc ;
error :
goto done ;
}
INT32 _rtnLocalLobStream::_queryLobMeta4Write( _pmdEDUCB *cb,
_dmsLobMeta &meta,
_rtnLobPiecesInfo* piecesInfo )
{
INT32 rc = SDB_OK ;
_rtnLobMetaCache* metaCache = NULL ;
const _dmsLobMeta* cachedMeta = NULL ;
BOOLEAN accessInfoLocked = FALSE ;
SDB_ASSERT( NULL != _accessInfo, "_accessInfo is null" ) ;
SDB_ASSERT( SDB_LOB_MODE_WRITE == _getMode(), "should be write mode" ) ;
_accessInfo->lock() ;
accessInfoLocked = TRUE ;
metaCache = _accessInfo->getMetaCache() ;
if ( NULL == metaCache )
{
metaCache = SDB_OSS_NEW _rtnLobMetaCache() ;
if ( NULL == metaCache )
{
rc = SDB_OOM ;
PD_LOG( PDERROR, "Failed to new _rtnLobMetaCache, rc:%d", rc ) ;
goto error ;
}
_accessInfo->setMetaCache( metaCache ) ;
}
else
{
metaCache->setNeedMerge( TRUE ) ;
}
cachedMeta = metaCache->lobMeta() ;
if ( NULL == cachedMeta )
{
UINT32 readLen = 0 ;
UINT32 len = DMS_LOB_META_LENGTH ;
CHAR* buf = NULL ;
dmsLobRecord record ;
_getPool().clear() ;
rc = _getPool().allocate( len, &buf ) ;
if ( rc )
{
PD_LOG( PDERROR, "Failed to alloc buffer[%u], rc: %d",
len, rc ) ;
goto error ;
}
record.set( &getOID(), DMS_LOB_META_SEQUENCE, 0, len, NULL ) ;
rc = _su->lob()->read( record, _mbContext, cb, buf, readLen ) ;
if ( SDB_OK == rc )
{
if ( readLen < sizeof( meta ) )
{
PD_LOG( PDERROR, "Read lob[%s]'s meta page len is less than "
"meta size[%u]", getOID().str().c_str(),
sizeof( meta ) ) ;
rc = SDB_SYS ;
goto error ;
}
ossMemcpy( &meta, buf, sizeof( meta ) ) ;
if ( !meta.isDone() )
{
PD_LOG( PDINFO, "Lob[%s] meta[%s] is not available",
getOID().str().c_str(), meta.toString().c_str() ) ;
rc = SDB_LOB_IS_NOT_AVAILABLE ;
goto error ;
}
if ( meta.hasPiecesInfo() && NULL != piecesInfo )
{
INT32 length = meta._piecesInfoNum * (INT32)sizeof( _rtnLobPieces ) ;
const CHAR* pieces = (const CHAR*)
( buf + DMS_LOB_META_LENGTH - length ) ;
rc = piecesInfo->readFrom( pieces, length ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDINFO, "Failed to read pieces info of Lob[%s]",
getOID().str().c_str() ) ;
goto error ;
}
}
rc = metaCache->cache( *(_dmsLobMeta*)buf ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDINFO, "Failed to cache meta data of Lob[%s]",
getOID().str().c_str() ) ;
goto error ;
}
}
else
{
if ( SDB_LOB_SEQUENCE_NOT_EXIST == rc )
{
rc = SDB_FNE ;
}
else if ( SDB_FNE != rc )
{
PD_LOG( PDERROR, "Failed to get meta of lob, rc:%d", rc ) ;
}
goto error ;
}
}
else
{
ossMemcpy( &meta, cachedMeta, sizeof( meta ) ) ;
if ( meta.hasPiecesInfo() && NULL != piecesInfo )
{
INT32 length = meta._piecesInfoNum *
(INT32)sizeof( _rtnLobPieces ) ;
rc = piecesInfo->readFrom( (CHAR*)cachedMeta + DMS_LOB_META_LENGTH - length,
length ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to read lob pieces info, rc:%d", rc ) ;
goto error ;
}
}
}
done:
if ( accessInfoLocked )
{
_accessInfo->unlock() ;
accessInfoLocked = FALSE ;
}
return rc ;
error:
goto done ;
}
void setOption( const CHAR *optAddr, UINT32 optSize )
{
SDB_ASSERT( optAddr, "Option address is NULL" ) ;
ossMemcpy( (CHAR *)this + sizeof(_dmsOptExtent), optAddr, optSize ) ;
_optSize = optSize ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSRPCMGR__SEARCH, "_dpsReplicaLogMgr::_search" )
INT32 _dpsReplicaLogMgr::_search ( const DPS_LSN &lsn, _dpsMessageBlock *mb,
BOOLEAN onlyHeader )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__DPSRPCMGR__SEARCH );
dpsLogRecordHeader head ;
UINT32 offset = 0 ;
UINT32 len = 0 ;
UINT32 pageSub = 0 ;
DPS_LSN beginLSN ;
DPS_LSN lastLSN ;
BOOLEAN mtxLocked = FALSE ;
BOOLEAN pageLocked = FALSE ;
pageSub = ( lsn.offset / DPS_DEFAULT_PAGE_SIZE ) % _pageNum ;
offset = lsn.offset % DPS_DEFAULT_PAGE_SIZE ;
_mtx.get () ;
mtxLocked = TRUE ;
beginLSN = _getStartLsn() ;
if ( beginLSN.invalid() )
{
PD_LOG( PDERROR, "begin lsn invalid [offset:%lld] [version:%d]",
beginLSN.offset, beginLSN.version ) ;
rc = SDB_DPS_LOG_NOT_IN_BUF ;
goto error ;
}
lastLSN = _lsn ;
if ( 0 > lsn.compareOffset(beginLSN.offset) )
{
PD_LOG( PDDEBUG, "lsn %lld is smaller than membegin %lld",
lsn.offset, beginLSN.offset ) ;
rc = SDB_DPS_LOG_NOT_IN_BUF ;
goto error ;
}
else if ( 0 <= lsn.compareOffset(lastLSN.offset) )
{
rc = SDB_DPS_LSN_OUTOFRANGE ;
goto error ;
}
(&_pages[pageSub])->lock() ;
pageLocked = TRUE ;
_mtx.release() ;
mtxLocked = FALSE ;
rc = _parse ( pageSub, offset, sizeof(dpsLogRecordHeader),
(CHAR*)&head ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to parse log record, rc = %d", rc ) ;
goto error ;
}
if ( head._lsn != lsn.offset ||
head._length < sizeof(dpsLogRecordHeader) )
{
PD_LOG ( PDERROR, "Unexpected LSN is read, expects %lld, %d,"
"actually read %lld, %d",
lsn.offset, lsn.version, head._lsn, head._version ) ;
rc = SDB_DPS_CORRUPTED_LOG ;
goto error ;
}
if ( onlyHeader )
{
len = sizeof( dpsLogRecordHeader ) ;
}
else
{
len = head._length ;
}
if ( mb->idleSize() < len )
{
rc = mb->extend ( len - mb->idleSize () ) ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to extend mb, rc = %d", rc ) ;
goto error ;
}
}
if ( onlyHeader )
{
ossMemcpy( mb->writePtr(), (CHAR*)&head, len ) ;
}
else
{
rc = _parse ( pageSub, offset, len, mb->writePtr() ) ;
}
(&_pages[pageSub])->unlock() ;
pageLocked = FALSE ;
if ( rc )
{
PD_LOG ( PDERROR, "Failed to parse entire log, rc = %d", rc ) ;
goto error ;
}
mb->writePtr ( len + mb->length () ) ;
done :
if ( mtxLocked )
{
_mtx.release () ;
}
if ( pageLocked )
{
(&_pages[pageSub])->unlock() ;
}
PD_TRACE_EXITRC ( SDB__DPSRPCMGR__SEARCH, rc );
return rc ;
error :
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_RTNLOCALLOBSTREAM__UPDATE, "_rtnLocalLobStream::_update" )
INT32 _rtnLocalLobStream::_update( const _rtnLobTuple &tuple,
_pmdEDUCB *cb )
{
INT32 rc = SDB_OK ;
BOOLEAN accessInfoLocked = FALSE ;
PD_TRACE_ENTRY( SDB_RTNLOCALLOBSTREAM__UPDATE ) ;
dmsLobRecord record ;
const MsgLobTuple &t = tuple.tuple ;
CHAR* buf = NULL ;
record.set( &getOID(), t.columns.sequence, t.columns.offset,
t.columns.len, ( const CHAR * )tuple.data ) ;
if ( DMS_LOB_META_SEQUENCE == t.columns.sequence &&
SDB_LOB_MODE_WRITE == _getMode() &&
0 == t.columns.offset &&
t.columns.len >= sizeof(_dmsLobMeta) )
{
_rtnLobMetaCache* metaCache = NULL ;
const _dmsLobMeta* meta = (const _dmsLobMeta*)tuple.data ;
if ( meta->hasPiecesInfo() && t.columns.len < DMS_LOB_META_LENGTH )
{
rc = SDB_SYS ;
PD_LOG( PDERROR, "Invalid lob meta data length:%d, rc=%d",
t.columns.len, rc ) ;
goto error ;
}
SDB_ASSERT( NULL != _accessInfo, "_accessInfo is null" ) ;
_accessInfo->lock() ;
accessInfoLocked = TRUE ;
metaCache = _accessInfo->getMetaCache() ;
SDB_ASSERT( NULL != metaCache, "metaCache is null" ) ;
SDB_ASSERT( NULL != metaCache->lobMeta(), "lob meta cache is null" ) ;
if ( metaCache->needMerge() )
{
_rtnLobMetaCache newCache ;
rc = newCache.cache( *(metaCache->lobMeta()) ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to cache lob meta, rc=%d", rc ) ;
goto error ;
}
rc = newCache.merge( *meta, _su->getLobPageSize() ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to merge lob meta data, rc=%d", rc ) ;
goto error ;
}
SDB_ASSERT( NULL != newCache.lobMeta(), "new lob meta cache is null" ) ;
rc = metaCache->cache( *( newCache.lobMeta() ) ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to cache lob meta, rc=%d", rc ) ;
goto error ;
}
buf = (CHAR*)SDB_OSS_MALLOC( record._dataLen > DMS_LOB_META_LENGTH ?
record._dataLen : DMS_LOB_META_LENGTH ) ;
if ( NULL == buf )
{
rc = SDB_OOM ;
PD_LOG( PDERROR, "Failed to malloc buf, rc=%d", rc ) ;
goto error ;
}
ossMemset( buf, 0, DMS_LOB_META_LENGTH ) ;
ossMemcpy( buf, record._data, record._dataLen ) ;
record._data = (const CHAR*)buf ;
if ( newCache.lobMeta()->hasPiecesInfo() )
{
ossMemcpy( (void*)record._data, newCache.lobMeta(), DMS_LOB_META_LENGTH ) ;
if ( record._dataLen < DMS_LOB_META_LENGTH )
{
record._dataLen = DMS_LOB_META_LENGTH ;
}
}
else
{
ossMemcpy( (void*)record._data, newCache.lobMeta(), sizeof( _dmsLobMeta ) ) ;
}
}
else
{
rc = metaCache->cache( *meta ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "Failed to cache lob meta, rc=%d", rc ) ;
goto error ;
}
}
rc = _su->lob()->update( record, _mbContext, cb, _getDPSCB() ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "failed to update to lob:%d", rc ) ;
goto error ;
}
_accessInfo->unlock() ;
accessInfoLocked = FALSE ;
}
else
{
rc = _su->lob()->update( record, _mbContext, cb, _getDPSCB() ) ;
if ( SDB_OK != rc )
{
PD_LOG( PDERROR, "failed to update to lob:%d", rc ) ;
goto error ;
}
}
done:
if ( accessInfoLocked )
{
_accessInfo->unlock() ;
}
SAFE_OSS_FREE( buf ) ;
PD_TRACE_EXITRC( SDB_RTNLOCALLOBSTREAM__UPDATE, rc ) ;
return rc ;
error:
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__IXMINXCB2, "_ixmIndexCB::_ixmIndexCB" )
_ixmIndexCB::_ixmIndexCB ( dmsExtentID extentID,
const BSONObj &infoObj,
UINT16 mbID ,
_dmsStorageIndex *pIndexSu,
_dmsContext *context )
{
SDB_ASSERT ( pIndexSu, "index su can't be NULL" ) ;
PD_TRACE_ENTRY ( SDB__IXMINXCB2 );
ixmIndexCBExtent *pExtent = NULL ;
_isInitialized = FALSE ;
dmsExtRW extRW ;
_pIndexSu = pIndexSu ;
_pContext = context ;
_extentID = extentID ;
_pageSize = _pIndexSu->pageSize() ;
_extent = (const ixmIndexCBExtent*)pIndexSu->beginFixedAddr ( extentID,
1 ) ;
extRW = pIndexSu->extent2RW( extentID, context->mbID() ) ;
pExtent = extRW.writePtr<ixmIndexCBExtent>( 0, _pageSize ) ;
if ( infoObj.objsize() + IXM_INDEX_CB_EXTENT_METADATA_SIZE >=
(UINT32)_pageSize )
{
PD_LOG ( PDERROR, "index object is too big: %s",
infoObj.toString().c_str() ) ;
goto error ;
}
pExtent->_type = IXM_EXTENT_TYPE_NONE ;
if ( !generateIndexType( infoObj, pExtent->_type ) )
{
goto error ;
}
pExtent->_flag = DMS_EXTENT_FLAG_INUSE ;
pExtent->_eyeCatcher [0] = IXM_EXTENT_CB_EYECATCHER0 ;
pExtent->_eyeCatcher [1] = IXM_EXTENT_CB_EYECATCHER1 ;
pExtent->_indexFlag = IXM_INDEX_FLAG_INVALID ;
pExtent->_mbID = mbID ;
pExtent->_version = DMS_EXTENT_CURRENT_V ;
pExtent->_logicID = DMS_INVALID_EXTENT ;
pExtent->_scanExtLID = DMS_INVALID_EXTENT ;
pExtent->_rootExtentID = DMS_INVALID_EXTENT ;
ossMemset( pExtent->_reserved, 0, sizeof( pExtent->_reserved ) ) ;
if ( !infoObj.hasField (DMS_ID_KEY_NAME) )
{
_IDToInsert oid ;
oid._oid.init() ;
*(INT32*)(((CHAR*)pExtent) +IXM_INDEX_CB_EXTENT_METADATA_SIZE) =
infoObj.objsize() + sizeof(_IDToInsert) ;
ossMemcpy ( ((CHAR*)pExtent) +
IXM_INDEX_CB_EXTENT_METADATA_SIZE +
sizeof(INT32),
(CHAR*)(&oid),
sizeof(_IDToInsert)) ;
ossMemcpy ( ((CHAR*)pExtent) +
IXM_INDEX_CB_EXTENT_METADATA_SIZE +
sizeof(INT32) +
sizeof(_IDToInsert),
infoObj.objdata()+sizeof(INT32),
infoObj.objsize()-sizeof(INT32) ) ;
}
else
{
ossMemcpy ( ((CHAR*)pExtent) +
IXM_INDEX_CB_EXTENT_METADATA_SIZE,
infoObj.objdata(),
infoObj.objsize() ) ;
}
_init() ;
done :
PD_TRACE_EXIT ( SDB__IXMINXCB2 );
return ;
error :
goto done ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_UPNFYLIST, "_clsSyncManager::updateNotifyList" )
INT32 _clsSyncManager::updateNotifyList( BOOLEAN newNodeValid )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_UPNFYLIST ) ;
map<UINT64, _clsSharingStatus> &group = _info->info ;
UINT32 removed = 0 ;
UINT32 prevAlives = 0 ;
UINT32 aliveRemoved = 0 ;
_clsSyncStatus status[CLS_REPLSET_MAX_NODE_SIZE - 1] ;
UINT32 valid = 0 ;
ossScopedRWLock lock( &_info->mtx, EXCLUSIVE ) ;
_aliveCount = _info->alives.size() ;
for ( UINT32 i = 0; i < _validSync ; i++ )
{
if ( _notifyList[i].valid )
{
++prevAlives ;
}
if ( group.end() ==
group.find( _notifyList[i].id.value ) )
{
if ( _notifyList[i].valid )
{
++aliveRemoved ;
}
++removed ;
}
else
{
status[valid] = _notifyList[i] ;
++valid ;
}
}
if ( 0 != removed )
{
_clearSyncList( removed, aliveRemoved, prevAlives,
_validSync, _notifyList ) ;
}
UINT32 merge = valid ;
map<UINT64, _clsSharingStatus>::const_iterator itr =
group.begin() ;
for ( ; itr != group.end(); itr++ )
{
BOOLEAN has = FALSE ;
for ( UINT32 j = 0; j < valid; j++ )
{
if ( itr->first == status[j].id.value )
{
has = TRUE ;
break ;
}
}
if ( !has )
{
status[merge].offset = 0 ;
status[merge].id.value = itr->first ;
status[merge].valid = newNodeValid ;
++merge ;
}
}
ossMemcpy( _notifyList, status, merge * sizeof( _clsSyncStatus ) ) ;
_validSync = merge ;
PD_TRACE_EXITRC ( SDB__CLSSYNCMAG_UPNFYLIST, rc ) ;
return rc ;
}
