// PD_TRACE_DECLARE_FUNCTION ( SDB__NETEVNHND_SYNCSND, "_netEventHandler::syncSend" )
INT32 _netEventHandler::syncSend( const void *buf,
UINT32 len )
{
INT32 rc = SDB_OK ;
PD_TRACE_ENTRY ( SDB__NETEVNHND_SYNCSND );
UINT32 send = 0 ;
_lastSendTick = pmdGetDBTick() ;
try
{
while ( send < len )
{
send += _sock.send(buffer((const void*)((ossValuePtr)buf + send),
len - send));
}
}
catch ( boost::system::system_error &e )
{
PD_LOG( PDERROR, "Failed to send to node :%d, %d, %d, %s",
_id.columns.groupID, _id.columns.nodeID,
_id.columns.serviceID, e.what() ) ;
rc = SDB_NET_SEND_ERR ;
goto error ;
}
done:
PD_TRACE_EXITRC ( SDB__NETEVNHND_SYNCSND, rc );
return rc ;
error:
goto done ;
}
_netEventHandler::_netEventHandler( _netFrame *frame ):
_sock(frame->ioservice()),
_buf(NULL),
_bufLen(0),
_state(NET_EVENT_HANDLER_STATE_HEADER),
_frame(frame),
_handle(_frame->allocateHandle())
{
_id.value = MSG_INVALID_ROUTEID ;
_isConnected = FALSE ;
_isInAsync = FALSE ;
_hasRecvMsg = FALSE ;
_lastSendTick = pmdGetDBTick() ;
_lastRecvTick = pmdGetDBTick() ;
_lastBeatTick = pmdGetDBTick() ;
_isAcitve = FALSE ;
_msgid = 0 ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__DPSLGWRAPP_WRITEDATA, "_dpsLogWrapper::writeData" )
void _dpsLogWrapper::writeData ( dpsMergeInfo & info )
{
PD_TRACE_ENTRY ( SDB__DPSLGWRAPP_WRITEDATA ) ;
_lastWriteTick = pmdGetDBTick() ;
++_writeReordNum ;
_buf.writeData( info ) ;
IExecutor *cb = info.getEDUCB() ;
if ( cb )
{
if ( info.hasDummy() )
{
cb->insertLsn( info.getDummyBlock().record().head()._lsn ) ;
}
cb->insertLsn( info.getMergeBlock().record().head()._lsn ) ;
}
if ( _vecEventHandler.size() > 0 && info.isNeedNotify() )
{
DPS_LSN_OFFSET offset = DPS_INVALID_LSN_OFFSET ;
if ( info.hasDummy() )
{
offset = info.getDummyBlock().record().head()._lsn ;
for( UINT32 i = 0 ; i < _vecEventHandler.size() ; ++i )
{
_vecEventHandler[i]->onWriteLog( offset ) ;
}
}
offset = info.getMergeBlock().record().head()._lsn ;
for( UINT32 i = 0 ; i < _vecEventHandler.size() ; ++i )
{
_vecEventHandler[i]->onWriteLog( offset ) ;
}
}
if ( info.isTransEnabled() && cb &&
DPS_INVALID_TRANS_ID != cb->getTransID() )
{
UINT64 transID = cb->getTransID() ;
cb->setCurTransLsn( info.getMergeBlock().record().head()._lsn ) ;
if ( sdbGetTransCB()->isFirstOp( transID ) )
{
sdbGetTransCB()->clearFirstOpTag( transID ) ;
cb->setTransID( transID ) ;
}
}
info.resetInfoEx() ;
PD_TRACE_EXIT( SDB__DPSLGWRAPP_WRITEDATA ) ;
}
// 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 ;
}
UINT64 _SDB_KRCB::getDBTick() const
{
return pmdGetDBTick() ;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__NETEVNHND__RDCALLBK, "_netEventHandler::_readCallback" )
void _netEventHandler::_readCallback( const boost::system::error_code &
error )
{
PD_TRACE_ENTRY ( SDB__NETEVNHND__RDCALLBK ) ;
if ( error )
{
if ( error.value() == boost::system::errc::operation_canceled ||
error.value() == boost::system::errc::no_such_file_or_directory )
{
PD_LOG ( PDINFO, "connection aborted, node:%d, %d, %d",
_id.columns.groupID, _id.columns.nodeID,
_id.columns.serviceID ) ;
}
else
{
PD_LOG ( PDERROR, "Error received, node:%d, %d, %d, err=%d",
_id.columns.groupID, _id.columns.nodeID,
_id.columns.serviceID, error.value() ) ;
}
goto error_close ;
}
_lastRecvTick = pmdGetDBTick() ;
_lastBeatTick = _lastRecvTick ;
if ( NET_EVENT_HANDLER_STATE_HEADER == _state )
{
if ( ( UINT32 )MSG_SYSTEM_INFO_LEN == (UINT32)_header.messageLength )
{
if ( SDB_OK != _allocateBuf( sizeof(MsgSysInfoRequest) ))
{
goto error_close ;
}
_hasRecvMsg = TRUE ;
ossMemcpy( _buf, &_header, sizeof( MsgSysInfoRequest ) ) ;
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
goto done ;
}
else if ( sizeof(_MsgHeader) > (UINT32)_header.messageLength ||
SDB_MAX_MSG_LENGTH < (UINT32)_header.messageLength )
{
PD_LOG( PDERROR, "Error header[len: %d, opCode: (%d)%d, TID:%d] "
"received, node:%d, %d, %d", _header.messageLength,
IS_REPLY_TYPE(_header.opCode) ? 1 : 0,
GET_REQUEST_TYPE(_header.opCode), _header.TID,
_id.columns.groupID,
_id.columns.nodeID, _id.columns.serviceID ) ;
goto error_close ;
}
else
{
if ( FALSE == _hasRecvMsg )
{
_hasRecvMsg = TRUE ;
_state = NET_EVENT_HANDLER_STATE_HEADER_LAST ;
asyncRead() ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
goto done ;
}
PD_LOG( PDDEBUG, "msg header: [len:%d], [opCode: [%d]%d], "
"[TID:%d], [groupID:%d], [nodeID:%d], "
"[ADDR:%s], [PORT:%d]",
_header.messageLength, IS_REPLY_TYPE(_header.opCode)?1:0,
GET_REQUEST_TYPE(_header.opCode),
_header.TID, _header.routeID.columns.groupID,
_header.routeID.columns.nodeID,
remoteAddr().c_str(), remotePort() ) ;
if ( MSG_INVALID_ROUTEID == _id.value )
{
if ( MSG_INVALID_ROUTEID != _header.routeID.value )
{
_id = _header.routeID ;
_frame->_addRoute( shared_from_this() ) ;
}
}
}
if ( (UINT32)sizeof(_MsgHeader) == (UINT32)_header.messageLength )
{
if ( SDB_OK != _allocateBuf( sizeof(_MsgHeader) ))
{
goto error_close ;
}
ossMemcpy( _buf, &_header, sizeof( _MsgHeader ) ) ;
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
goto done ;
}
#if defined (_LINUX)
try
{
boost::asio::detail::socket_option::boolean<IPPROTO_TCP, TCP_QUICKACK>
quickack( TRUE ) ;
_sock.set_option( quickack ) ;
}
catch ( boost::system::system_error &e )
{
PD_LOG ( PDERROR, "Failed to quick ack: %s", e.what() ) ;
}
#endif // _LINUX
_state = NET_EVENT_HANDLER_STATE_BODY ;
asyncRead() ;
}
else
{
_frame->handleMsg( shared_from_this() ) ;
_state = NET_EVENT_HANDLER_STATE_HEADER ;
asyncRead() ;
}
done:
PD_TRACE_EXIT ( SDB__NETEVNHND__RDCALLBK ) ;
return ;
error_close:
if ( _isConnected )
{
close() ;
}
_frame->handleClose( shared_from_this(), _id ) ;
_frame->_erase( handle() ) ;
goto done ;
}
void _netEventHandler::syncLastBeatTick()
{
_lastBeatTick = pmdGetDBTick() ;
}
