_rtnQueryOptions::~_rtnQueryOptions () { SAFE_OSS_FREE( _fullNameBuf ) ; SAFE_OSS_FREE( _mainCLNameBuf ) ; _fullName = NULL ; _mainCLName = NULL ; }
migMaster::~migMaster() { if ( _ppBucket ) { for ( UINT32 i = 0; i < _pParameters->bucketNum; ++i ) { SAFE_OSS_DELETE ( _ppBucket[i] ) ; } } SAFE_OSS_FREE ( _ppBucket ) ; SAFE_OSS_DELETE ( _parser ) ; SAFE_OSS_FREE ( _sendMsg ) ; }
utilZlibInStream::~utilZlibInStream() { if ( NULL != _zbuf ) { SAFE_OSS_FREE( _zbuf ) ; } if ( NULL != _zstream ) { inflateEnd( _zstream ) ; SAFE_OSS_FREE( _zstream ) ; } }
_rtnQueryOptions &_rtnQueryOptions::operator = ( const _rtnQueryOptions &o ) { _rtnReturnOptions::operator =( o ) ; _query = o._query ; _orderBy = o._orderBy ; _hint = o._hint ; _fullName = o._fullName ; SAFE_OSS_FREE( _fullNameBuf ) ; _mainCLName = o._mainCLName ; SAFE_OSS_FREE( _mainCLNameBuf ) ; return *this ; }
INT32 utilZlibInStream::init( utilInStream& upstream, INT32 bufSize ) { INT32 rc = SDB_OK ; SDB_ASSERT( !_inited, "inited" ) ; _zbuf = (CHAR*)SDB_OSS_MALLOC( bufSize ) ; if ( NULL == _zbuf ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Failed to malloc zlib instream buffer, rc=%d", rc ) ; goto error ; } _zbufSize = bufSize ; _zstream = (z_stream*)SDB_OSS_MALLOC( sizeof( z_stream ) ) ; if ( NULL == _zstream ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Failed to malloc z_stream, rc=%d", rc ) ; goto error ; } _zstream->zalloc = _zlib_alloc ; _zstream->zfree = _zlib_free ; _zstream->opaque = NULL ; _zstream->next_in = NULL ; _zstream->avail_in = 0 ; rc = inflateInit( _zstream ) ; if ( Z_OK != rc ) { PD_LOG( PDERROR, "Failed to init z_stream, zlib error=%d", rc ) ; rc = SDB_UTIL_COMPRESS_INIT_FAIL ; goto error; } _upstream = &upstream ; _inited = TRUE ; done: return rc ; error: SAFE_OSS_FREE( _zstream ) ; SAFE_OSS_FREE( _zbuf ) ; goto done ; }
INT32 utilJsonFile::read( ossFile& file, bson::BSONObj& data ) { INT64 fileSize = 0 ; INT64 readSize = 0 ; CHAR* buf = NULL ; INT32 rc = SDB_OK ; SDB_ASSERT( file.isOpened(), "file should be opened" ) ; rc = file.getFileSize( fileSize ) ; if ( SDB_OK != rc ) { PD_LOG( PDERROR, "Failed to get file size, rc=%d", rc ) ; goto error ; } SDB_ASSERT( fileSize >= 0, "file size should be >= 0" ) ; if ( 0 == fileSize ) { goto done ; } buf = (CHAR*)SDB_OSS_MALLOC( fileSize + 1 ) ; // one more byte for safe if ( NULL == buf ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Failed to malloc, mem size = %lld, rc=%d", fileSize + 1, rc ) ; goto error ; } rc = file.seekAndReadN( 0, buf, fileSize, readSize ) ; if ( SDB_OK != rc ) { PD_LOG( PDERROR, "Failed to read from file, rc=%d", rc ) ; goto error ; } SDB_ASSERT( readSize == fileSize, "readSize != fileSize" ) ; buf[ readSize ] = '\0' ; // safe guard rc = bson::fromjson( buf, data ) ; if ( SDB_OK != rc ) { PD_LOG( PDERROR, "Failed to convert json[%s] to bson, rc=%d", buf, rc ) ; goto error ; } done: SAFE_OSS_FREE( buf ) ; return rc ; error: goto done ; }
void _rtnQueryOptions::setMainCLName ( const CHAR *mainCLName ) { SAFE_OSS_FREE( _mainCLNameBuf ) ; if ( NULL != mainCLName && '\0' != mainCLName[0] ) { _mainCLName = mainCLName ; } else { _mainCLName = NULL ; } }
void _rtnQueryOptions::setCLFullName ( const CHAR *clFullName ) { SAFE_OSS_FREE( _fullNameBuf ) ; if ( NULL != clFullName && '\0' != clFullName[0] ) { _fullName = clFullName ; } else { _fullName = NULL ; } }
INT32 _rtnQueryOptions::getOwned () { INT32 rc = SDB_OK ; _rtnReturnOptions::getOwned() ; SAFE_OSS_FREE( _fullNameBuf ) ; if ( NULL != _fullName ) { _fullNameBuf = ossStrdup( _fullName ) ; if ( NULL == _fullNameBuf ) { rc = SDB_OOM ; goto error ; } } _fullName = _fullNameBuf ; SAFE_OSS_FREE( _mainCLNameBuf ) ; if ( NULL != _mainCLName ) { _mainCLNameBuf = ossStrdup( _mainCLName ) ; if ( NULL == _mainCLNameBuf ) { rc = SDB_OOM ; goto error ; } } _mainCLName = _mainCLNameBuf ; _query = _query.getOwned() ; _orderBy = _orderBy.getOwned() ; _hint = _hint.getOwned() ; done: return rc ; error: goto done ; }
INT32 _appendObj( CHAR delChar, bson_iterator *pIt, CHAR **ppCSVBuf, INT32 *pCSVSize ) { INT32 rc = SDB_OK ; INT32 size = 0 ; INT32 objSize = 0 ; CHAR *pBuffer = NULL ; CHAR *pTempBuf = NULL ; size = bson_sprint_length_iterator ( pIt ) ; if ( ppCSVBuf && size > (*pCSVSize) ) { rc = SDB_OOM ; goto error ; } pBuffer = (CHAR *)SDB_OSS_MALLOC( size ) ; if ( !pBuffer ) { rc = SDB_OOM ; goto error ; } pTempBuf = pBuffer ; ossMemset( pTempBuf, 0, size ) ; objSize = size ; if( !bson_sprint_iterator ( &pTempBuf, &size, pIt, '"' ) ) { rc = SDB_OOM ; goto error ; } objSize -= size ; rc = _appendString( delChar, pBuffer, objSize, ppCSVBuf, pCSVSize ) ; if ( rc ) { goto error ; } done: SAFE_OSS_FREE( pBuffer ) ; return rc ; error: goto done ; }
INT32 _clsLocalValidation::run() { INT32 rc = SDB_OK ; const UINT32 pLen = 512 ; SDB_RTNCB *rtnCB = sdbGetRTNCB() ; SDB_DMSCB *dmsCB = sdbGetDMSCB() ; CHAR *p = (CHAR *)SDB_OSS_MALLOC( pLen ) ; if ( NULL == p ) { PD_LOG( PDERROR, "failed to allocate mem." ) ; rc = SDB_OOM ; goto error ; } *p = '\0' ; *( p + pLen - 1 ) = '\0' ; /*try { boost::thread t( func ) ; t.join() ; } catch( std::exception &e ) { PD_LOG( PDERROR, "failed to create new thread:%s", e.what() ) ; rc = SDB_SYS ; goto error ; }*/ pmdUpdateValidationTick() ; done: SAFE_OSS_FREE( p ) ; return rc ; error: goto done ; }
INT32 iPmdDMNChildProc::init( ossSHMKey shmKey ) { INT32 rc = SDB_OK; UINT32 len = 0; #if defined (_WINDOWS) UINT32 keyLen = 0; #endif ossMemset( _execName, 0, sizeof( _execName) ); rc = ossGetEWD( _execName, OSS_MAX_PATHSIZE ); PD_RC_CHECK( rc, PDERROR, "failed to get working directory(rc=%d)", rc ); len = ossStrlen( _execName ); len = len + 1 + ossStrlen( getProgramName() ); #if defined (_WINDOWS) len += ossStrlen(".exe"); keyLen = ossStrlen( shmKey ); SAFE_OSS_FREE( _shmKey ); _shmKey = (CHAR *)SDB_OSS_MALLOC( keyLen + 1 ); if ( _shmKey ) { ossStrcpy( _shmKey, shmKey ); } #elif defined ( _LINUX ) _shmKey = shmKey; #endif PD_CHECK( len <= OSS_MAX_PATHSIZE, SDB_INVALIDARG, error, PDERROR, "length of working directory is longer than expected!" ); ossStrncat( _execName, OSS_FILE_SEP, 1 ); ossStrncat( _execName, getProgramName(), ossStrlen( getProgramName() ) ); #if defined (_WINDOWS) ossStrncat( _execName, ".exe", ossStrlen(".exe") ); #endif done: return rc; error: goto done; }
INT32 _utilESBulkBuilder::init( UINT32 bufferSize ) { INT32 rc = SDB_OK ; if ( 0 == bufferSize || bufferSize > UTIL_ESBULK_MAX_SIZE ) { rc = SDB_INVALIDARG ; PD_LOG( PDERROR, "Buffer size[ %u ] is invalid", bufferSize ) ; goto error ; } if ( _buffer ) { SDB_ASSERT( _capacity, "_capacity is 0" ) ; rc = SDB_INVALIDARG ; PD_LOG( PDERROR, "Bulk builder has been initialized already" ) ; goto error ; } _buffer = (CHAR *)SDB_OSS_MALLOC( bufferSize ) ; if ( !_buffer ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Allocate memory for bulk buffer failed, requested " "size[ %d ]", bufferSize ) ; goto error ; } ossMemset( _buffer, 0, bufferSize ) ; _capacity = bufferSize ; done: return rc ; error: SAFE_OSS_FREE( _buffer ) ; goto done ; }
migExport::~migExport () { if ( _isOpen ) { ossClose ( _file ) ; } if ( _gCursor ) { sdbCloseCursor( _gCursor ) ; sdbReleaseCursor( _gCursor ) ; } if ( _gCSList ) { sdbCloseCursor( _gCSList ) ; sdbReleaseCursor( _gCSList ) ; } if ( _gCLList ) { sdbCloseCursor( _gCLList ) ; sdbReleaseCursor( _gCLList ) ; } if ( _gCollection ) { sdbReleaseCollection ( _gCollection ) ; } if ( _gCollectionSpace ) { sdbReleaseCS ( _gCollectionSpace ) ; } if ( _gConnection ) { sdbDisconnect ( _gConnection ) ; sdbReleaseConnection( _gConnection ) ; } SAFE_OSS_FREE( _pBuffer ) ; }
INT32 _appendValue( CHAR delChar, bson_iterator *pIt, CHAR **ppBuffer, INT32 *pCSVSize, BOOLEAN includeBinary, BOOLEAN includeRegex ) { INT32 rc = SDB_OK ; bson_type type = bson_iterator_type( pIt ) ; INT32 tempSize = 0 ; INT32 base64Size = 0 ; INT32 binType = 0 ; CHAR temp[128] = { 0 } ; const CHAR *pTemp = NULL ; CHAR *pBase64 = NULL ; bson_timestamp_t ts; time_t timer ; struct tm psr; if ( type == BSON_DOUBLE || type == BSON_BOOL || type == BSON_NULL || type == BSON_INT || type == BSON_LONG ) { rc = _appendNonString( delChar, pIt, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else { rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } if ( type == BSON_TIMESTAMP ) { ts = bson_iterator_timestamp( pIt ) ; timer = (time_t)ts.t; local_time( &timer, &psr ) ; tempSize = ossSnprintf ( temp, 64, "%04d-%02d-%02d-%02d.%02d.%02d.%06d", psr.tm_year + 1900, psr.tm_mon + 1, psr.tm_mday, psr.tm_hour, psr.tm_min, psr.tm_sec, ts.i ) ; rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_DATE ) { timer = bson_iterator_date( pIt ) / 1000 ; local_time( &timer, &psr ) ; tempSize = ossSnprintf ( temp, 64, "%04d-%02d-%02d", psr.tm_year + 1900, psr.tm_mon + 1, psr.tm_mday ) ; rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_UNDEFINED ) { rc = _appendString( delChar, CSV_STR_UNDEFINED, CSV_STR_UNDEFINED_SIZE, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_MINKEY ) { rc = _appendString( delChar, CSV_STR_MINKEY, CSV_STR_MINKEY_SIZE, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_MAXKEY ) { rc = _appendString( delChar, CSV_STR_MAXKEY, CSV_STR_MAXKEY_SIZE, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_CODE ) { pTemp = bson_iterator_code( pIt ) ; rc = _appendString( delChar, pTemp, ossStrlen( pTemp ), ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_STRING || type == BSON_SYMBOL ) { pTemp = bson_iterator_string( pIt ) ; rc = _appendString( delChar, pTemp, ossStrlen( pTemp ), ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_BINDATA ) { if( TRUE == includeBinary ) { rc = _appendString( delChar, CSV_STR_LEFTBRACKET, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } binType = (INT32)bson_iterator_bin_type( pIt ) ; tempSize = ossSnprintf ( temp, 64, "%d", binType ) ; rc = _appendString( delChar, &temp, tempSize, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } rc = _appendString( delChar, CSV_STR_RIGHTBRACKET, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } pTemp = bson_iterator_bin_data( pIt ) ; tempSize = bson_iterator_bin_len ( pIt ) ; base64Size = getEnBase64Size ( tempSize ) ; pBase64 = (CHAR *)SDB_OSS_MALLOC( base64Size ) ; if( NULL == pBase64 ) { rc = SDB_OOM ; goto error ; } ossMemset( pBase64, 0, base64Size ) ; if ( !base64Encode( pTemp, tempSize, pBase64, base64Size ) ) { rc = SDB_OOM ; goto error ; } rc = _appendString( delChar, pBase64, base64Size - 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else if ( type == BSON_REGEX ) { if( TRUE == includeRegex ) { rc = _appendString( delChar, CSV_STR_BACKSLASH, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } pTemp = bson_iterator_regex( pIt ) ; rc = _appendString( delChar, pTemp, ossStrlen( pTemp ), ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } if( TRUE == includeRegex ) { rc = _appendString( delChar, CSV_STR_BACKSLASH, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } pTemp = bson_iterator_regex_opts( pIt ) ; rc = _appendString( delChar, pTemp, ossStrlen( pTemp ), ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } } else if ( type == BSON_OID ) { bson_oid_to_string( bson_iterator_oid( pIt ), temp ) ; rc = _appendString( delChar, temp, 24, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } else { rc = _appendObj( delChar, pIt, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } done: SAFE_OSS_FREE( pBase64 ) ; return rc ; error: goto done ; }
INT32 _sptClassMetaInfo::_extractTroffInfo() { INT32 rc = SDB_OK ; stringstream ss ; INT64 fileSize = 4096 ; CHAR *pFileBuff = NULL ; multimap<string, string>::iterator it ; MAP_FUNC_META_INFO_IT it2 ; pFileBuff = (CHAR *)SDB_OSS_MALLOC( fileSize ) ; if ( !pFileBuff ) { rc = SDB_OOM ; ss << "Failed to alloc memory, rc = " << rc << ERROR_END ; goto error ; } for( it = _mapFiles.begin(); it != _mapFiles.end(); it++ ) { sptFuncMetaInfo metaInfo ; string className = it->first ; string filePath = it->second ; string funcName ; string fullName ; vector<string> syntax ; string desc ; ossMemset( pFileBuff, 0, fileSize ) ; rc = _readFile( filePath.c_str(), &pFileBuff, &fileSize ) ; if ( rc ) { ss << "Failed to read troff's contents from file [" << filePath.c_str() << ", rc = " << rc << ERROR_END ; goto error ; } rc = _getFuncName( filePath, funcName ) ; if ( rc ) { ss << "Failed to get the name of function, rc = " << rc << ERROR_END ; goto error ; } rc = _getFuncSynopsis( pFileBuff, fileSize, syntax ) ; if ( rc ) { ss << "Failed to get the syntax of function in file[" << filePath << "], rc = " << rc << ERROR_END ; goto error ; } rc = _getFuncDesc( pFileBuff, fileSize, desc ) ; if ( rc ) { ss << "Failed to get the description of function in file[" << filePath << "], rc = " << rc << ERROR_END ; goto error ; } metaInfo.funcName = funcName ; metaInfo.syntax = syntax ; metaInfo.desc = desc ; metaInfo.funcType = SPT_FUNC_INSTANCE ; metaInfo.path = filePath ; it2 = _map_func_meta_info.find( className ) ; if ( it2 != _map_func_meta_info.end() ) { it2->second.push_back( metaInfo ) ; } else { vector<sptFuncMetaInfo> vec ; vec.push_back( metaInfo ) ; _map_func_meta_info.insert( PAIR_FUNC_META_INFO( className, vec ) ) ; } fullName = className + SPT_CLASS_SEPARATOR + funcName ; _functions.push_back( fullName ) ; } done: if ( pFileBuff ) { SAFE_OSS_FREE( pFileBuff ) ; } return rc ; error: PRINT_ERROR ; goto done ; }
INT32 utilZlibOutStream::init( utilOutStream& downstream, UTIL_COMPRESSION_LEVEL level, INT32 bufSize ) { INT32 rc = SDB_OK ; INT32 zlevel = 0 ; SDB_ASSERT( !_inited, "inited" ) ; _zbuf = (CHAR*)SDB_OSS_MALLOC( bufSize ) ; if ( NULL == _zbuf ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Failed to malloc zlib outstream buffer, rc=%d", rc ) ; goto error ; } _zbufSize = bufSize ; switch( level ) { case UTIL_COMP_BALANCE: zlevel = Z_DEFAULT_COMPRESSION ; break ; case UTIL_COMP_BEST_COMPRESSION: zlevel = Z_BEST_COMPRESSION ; break ; case UTIL_COMP_BEST_SPEED: zlevel = Z_BEST_SPEED ; break ; default: rc = SDB_INVALIDARG ; PD_LOG( PDERROR, "Invalid compression level: %d", level ) ; goto error ; } _level = level ; _zstream = (z_stream*)SDB_OSS_MALLOC( sizeof( z_stream ) ) ; if ( NULL == _zstream ) { rc = SDB_OOM ; PD_LOG( PDERROR, "Failed to malloc z_stream, rc=%d", rc ) ; goto error ; } _zstream->zalloc = _zlib_alloc ; _zstream->zfree = _zlib_free ; _zstream->opaque = NULL ; _zstream->data_type = Z_BINARY ; rc = deflateInit( _zstream, zlevel ) ; if ( Z_OK != rc ) { PD_LOG( PDERROR, "Failed to init z_stream, zlib error=%d", rc ) ; rc = SDB_UTIL_COMPRESS_INIT_FAIL ; goto error; } _downstream = &downstream ; _inited = TRUE ; done: return rc ; error: SAFE_OSS_FREE( _zstream ) ; SAFE_OSS_FREE( _zbuf ) ; goto done ; }
iPmdDMNChildProc::~iPmdDMNChildProc() { #if defined (_WINDOWS) SAFE_OSS_FREE( _shmKey ); #endif }
_mthSelector::~_mthSelector() { SAFE_OSS_FREE( _stringOutputBuffer ) ; }
_omagentJob::~_omagentJob() { SAFE_OSS_FREE( _pTask ) ; }
~_utilArray() { SAFE_OSS_FREE( _dynamicBuf ) ; }
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLOGFILE__RESTRORE, "_dpsLogFile::_restore" ) INT32 _dpsLogFile::_restore () { INT32 rc = SDB_OK ; PD_TRACE_ENTRY ( SDB__DPSLOGFILE__RESTRORE ); INT64 fileSize = 0 ; UINT64 offSet = 0 ; UINT64 baseOffset = 0 ; dpsLogRecordHeader lsnHeader ; CHAR *lastRecord = NULL ; UINT64 lastOffset = 0 ; UINT32 lastLen = 0 ; _inRestore = TRUE ; //Judge the length is right rc = ossGetFileSize( _file, &fileSize ) ; if ( SDB_OK != rc ) { goto error ; } if ( fileSize < (INT64)( _fileSize + sizeof(dpsLogHeader) ) ) { PD_LOG ( PDERROR, "DPS file size[%d] is smaller than config[%d]", fileSize - sizeof(dpsLogHeader), _fileSize ) ; rc = SDB_DPS_FILE_SIZE_NOT_SAME ; goto error ; } //Init header rc = _readHeader() ; if ( SDB_OK != rc ) { PD_LOG ( PDERROR, "Fail to read dps file header[rc:%d]", rc ) ; goto error ; } // check header info if ( ossStrncmp( _logHeader._eyeCatcher, DPS_LOG_HEADER_EYECATCHER, sizeof( _logHeader._eyeCatcher ) ) != 0 ) { PD_LOG( PDERROR, "DPS file eye catcher error" ) ; rc = SDB_DPS_FILE_NOT_RECOGNISE ; goto error ; } else if ( _logHeader._fileSize != 0 && _logHeader._fileSize != _fileSize ) { PD_LOG( PDERROR, "DPS file's meta size[%d] is not the same with " "config[%d]", _logHeader._fileSize, _fileSize ) ; rc = SDB_DPS_FILE_SIZE_NOT_SAME ; goto error ; } else if ( _logHeader._fileNum != 0 && _logHeader._fileNum != _fileNum ) { PD_LOG( PDERROR, "DPS file's meta file num[%d] is not the same with " "config[%d]", _logHeader._fileNum, _fileNum ) ; rc = SDB_INVALIDARG ; goto error ; } // check the real size if ( fileSize > (INT64)( _fileSize + sizeof(dpsLogHeader) ) ) { PD_LOG( PDERROR, "DPS file real size[%d] is not the same with " "config[%d]", fileSize - sizeof(dpsLogHeader), _fileSize ) ; // start up from crash if ( !pmdGetStartup().isOK() ) { rc = ossTruncateFile( _file, _fileSize + sizeof(dpsLogHeader) ) ; if ( rc ) { PD_LOG( PDWARNING, "Tuncate dps file to config size failed, " "rc: %d", rc ) ; goto error ; } PD_LOG( PDEVENT, "Tuncate dps file to config size[%d]", _fileSize ) ; } else { goto error ; } } PD_LOG ( PDEVENT, "Header info[first lsn:%d.%lld, logID:%d]", _logHeader._firstLSN.version, _logHeader._firstLSN.offset, _logHeader._logID ) ; // upgrade the header if ( _logHeader._version != DPS_LOG_FILE_VERSION1 ) { _logHeader._version = DPS_LOG_FILE_VERSION1 ; _logHeader._fileSize = _fileSize ; _logHeader._fileNum = _fileNum ; rc = _flushHeader() ; PD_RC_CHECK( rc, PDERROR, "Failed to flush header, rc: %d", rc ) ; } if ( _logHeader._logID == DPS_INVALID_LOG_FILE_ID || _logHeader._firstLSN.invalid() ) { _logHeader._firstLSN.version = DPS_INVALID_LSN_VERSION ; _logHeader._firstLSN.offset = DPS_INVALID_LSN_OFFSET ; goto done ; } offSet = _logHeader._firstLSN.offset % _fileSize ; baseOffset = _logHeader._firstLSN.offset - offSet ; //analysis the file while ( offSet < _fileSize ) { rc = read ( offSet + baseOffset , sizeof (dpsLogRecordHeader), (CHAR*)&lsnHeader ) ; if ( SDB_OK != rc ) { PD_LOG ( PDERROR, "Failed to read lsn header[offset:%lld,rc:%d]", offSet, rc ) ; goto error ; } if ( lsnHeader._lsn != offSet + baseOffset ) { PD_LOG ( PDEVENT, "LSN is not the same[%lld!=%lld]", lsnHeader._lsn, offSet + baseOffset ) ; break ; } else if ( offSet + lsnHeader._length > _fileSize ) { PD_LOG ( PDEVENT, "LSN length[%d] is over the file " "size[offSet:%lld]", lsnHeader._length, offSet ) ; break ; } else if ( lsnHeader._length < sizeof (dpsLogRecordHeader) ) { PD_LOG ( PDEVENT, "LSN length[%d] less than min[%d], invalid LSN", lsnHeader._length, sizeof (dpsLogRecordHeader) ) ; break ; } offSet += lsnHeader._length ; lastOffset = offSet ; lastLen = lsnHeader._length ; } /// ensure that the last record is valid. if ( 0 < lastLen && 0 < lastOffset ) { _dpsLogRecord lr ; lastRecord = ( CHAR * )SDB_OSS_MALLOC( lastLen ) ; if ( NULL == lastRecord ) { PD_LOG( PDERROR, "failed to allocate mem.") ; rc = SDB_OOM ; goto error ; } rc = read( lastOffset + baseOffset - lastLen, lastLen, lastRecord ) ; if ( SDB_OK != rc ) { PD_LOG( PDERROR, "failed to read dps record[%lld, rc:%d]", offSet, rc ) ; goto error ; } rc = lr.load( lastRecord ) ; if ( SDB_DPS_CORRUPTED_LOG == rc ) { /// the last record is corrupted. move to pre one. offSet -= lastLen ; rc = SDB_OK ; const dpsLogRecordHeader *corruptedHeader = ( const dpsLogRecordHeader * )lastRecord ; PD_LOG( PDEVENT, "last log record(lsn:%lld) is corrupted.", corruptedHeader->_lsn ) ; /// only one corrupted log in this file. if ( 0 == offSet ) { _logHeader._firstLSN.offset = DPS_INVALID_LSN_OFFSET ; _logHeader._firstLSN.version = DPS_INVALID_LSN_VERSION ; } } else if ( SDB_OK != rc ) { PD_LOG( PDERROR, "failed to load record log:%d", rc ) ; goto error ; } } _idleSize = _fileSize - offSet ; done: _inRestore = FALSE ; SAFE_OSS_FREE( lastRecord ) ; PD_TRACE_EXITRC ( SDB__DPSLOGFILE__RESTRORE, rc ); return rc ; error: goto done ; }
INT32 _sptClassMetaInfo::_getFuncSynopsis( const CHAR *pFileBuff, INT32 fileSize, vector<string> &output ) { INT32 rc = SDB_OK ; stringstream ss ; INT32 buffSize = 0 ; CHAR *pBuff = NULL ; vector<string> vec ; vector<string>::iterator it ; const CHAR *beg_mark = SPT_LANG_EN == _lang ? SPT_TROFF_SYNOPSIS_EN : SPT_TROFF_SYNOPSIS_CN ; const CHAR *end_mark = SPT_LANG_EN == _lang ? SPT_TROFF_CATEGORY_EN : SPT_TROFF_CATEGORY_CN ; rc = _getContents( pFileBuff, beg_mark, end_mark, &pBuff, &buffSize ) ; if ( SDB_OK != rc ) { ss << "Failed to contents for extracting synopsis, rc = " << rc << endl ; goto error ; } _filterMarks( pBuff, _uselessMarks, sizeof( _uselessMarks ) / sizeof( const CHAR * ) ) ; boost::split( vec, pBuff, boost::is_any_of("\n") ) ; for ( it = vec.begin(); it != vec.end(); it++ ) { if ( !it->empty() ) { std::size_t found = it->find( "(" ) ; if ( std::string::npos == found ) { output.push_back( *it ) ; } else { string sub = it->substr( 0, found ) ; found = sub.find_last_of( "." ) ; if ( std::string::npos == found ) { output.push_back( *it ) ; } else { output.push_back( it->substr( found + 1 ) ) ; } } } } done: if ( pBuff ) { SAFE_OSS_FREE( pBuff ) ; } return rc ; error: PRINT_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 ; }
INT32 _sptClassMetaInfo::_getFuncDesc( const CHAR *pFileBuff, INT32 fileSize, string &desc ) { INT32 rc = SDB_OK ; stringstream ss ; INT32 buffSize = 0 ; CHAR *pBuff = NULL ; const CHAR *pos = NULL ; const CHAR *beg_mark = SPT_LANG_EN == _lang ? SPT_TROFF_NAME_EN : SPT_TROFF_NAME_CN ; const CHAR *end_mark = SPT_LANG_EN == _lang ? SPT_TROFF_SYNOPSIS_EN : SPT_TROFF_SYNOPSIS_CN ; rc = _getContents( pFileBuff, beg_mark, end_mark, &pBuff, &buffSize ) ; if ( SDB_OK != rc ) { ss << "Failed to contents for extracting synopsis, rc = " << rc << endl ; goto error ; } _replaceCharsWithSpace( pBuff, "\n" ) ; _filterMarks( pBuff, _uselessMarks2, sizeof( _uselessMarks2 ) / sizeof( const CHAR * ) ) ; pos = ossStrstr( pBuff, "-" ) ; if ( NULL == pos ) { rc = SDB_INVALIDARG ; ss << "Failed to get the description of function, rc = " << rc << ERROR_END ; goto error ; } pos++ ; while( '\r' != *pos && '\n' != *pos ) { if ( ' ' == *pos ) { pos++ ; } else { break ; } } if ( '\r' != *pos && '\n' != *pos ) { desc += string( "- " ) + pos ; boost::trim( desc ) ; } done: if ( pBuff ) { SAFE_OSS_FREE( pBuff ) ; } return rc ; error: PRINT_ERROR ; goto done ; }