BOOL CUserFileObject::ReadFile( LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead )
{
BOOL bRes = FALSE;
if (lpNumberOfBytesRead)
{
*lpNumberOfBytesRead = 0;
}
if( 1 == m_bValid )
{
DWORD dwReadLen = 0;
m_rwLock.wlock();
bRes = m_pMemFileObject->ReadFileData(lpBuffer, nNumberOfBytesToRead, &dwReadLen,m_ulFilePointer);
if (lpNumberOfBytesRead)
{
*lpNumberOfBytesRead = dwReadLen;
}
m_ulFilePointer+=dwReadLen;
m_rwLock.unlock();
}
return bRes;
}
DWORD CUserFileObject::SetFilePointer( LONG lDistanceToMove, PLONG lpDistanceToMoveHigh,DWORD dwMoveMethod )
{
ULONGLONG ulNewFilePointer = 0;
if( 1 == m_bValid )
{
m_rwLock.wlock();
if( FILE_BEGIN == dwMoveMethod )
{
m_ulFilePointer = lDistanceToMove;
}
if( FILE_CURRENT == dwMoveMethod )
{
m_ulFilePointer += lDistanceToMove;
}
if( FILE_END == dwMoveMethod )
{
m_ulFilePointer = m_pMemFileObject->GetFileLength();
m_ulFilePointer += lDistanceToMove;
}
ulNewFilePointer = m_ulFilePointer;
m_rwLock.unlock();
}
return ulNewFilePointer;
}
BOOL CUserFileObject::WriteFile( LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten )
{
BOOL bRes = FALSE;
if (lpNumberOfBytesWritten)
{
*lpNumberOfBytesWritten = 0;
}
if( 1 == m_bValid )
{
DWORD dwWriteLen = 0;
m_rwLock.wlock();
bRes = m_pMemFileObject->WriteFileData(lpBuffer, nNumberOfBytesToWrite,&dwWriteLen,m_ulFilePointer);
if (lpNumberOfBytesWritten)
{
*lpNumberOfBytesWritten = dwWriteLen;
}
m_ulFilePointer+=dwWriteLen;
m_rwLock.unlock();
}
return bRes;
}
ULONGLONG GetFileLength()
{
if(FALSE==CheckSafe()) return FALSE;
ULONGLONG ulFileLen = 0;
m_rwLock.rlock();
ulFileLen = m_ulFileLen;
m_rwLock.unlock();
return ulFileLen;
}
BOOL ReadFileData( LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead,CONST ULONGLONG ulFilePointer )
{
if(FALSE==CheckSafe()) return FALSE;
m_rwLock.rlock();
ULONGLONG ulMaxReadLen = min(nNumberOfBytesToRead,(m_ulFileLen - ulFilePointer));
if ( ulMaxReadLen > 0 )
{
memcpy_s(lpBuffer,ulMaxReadLen,m_pMemBuf+ulFilePointer,ulMaxReadLen);
}
if(lpNumberOfBytesRead)
{
*lpNumberOfBytesRead = ulMaxReadLen;
}
m_rwLock.unlock();
return TRUE;
}
VOID CommonSetCookie(LPCSTR pchUrl,LPCSTR pchCookieData,BOOL bFromJs = FALSE)
{
CCookieParser cookieParser;
cookieParser.ParserCookieString(pchUrl,pchCookieData);
if (g_pDB)
{
char *pcherrmsg = NULL;
CStringA strSqlCmd;
strSqlCmd.Format("replace into cookiedata (domain,path,cookiename,cookievalue,secure,httponly,session) values('%s','%s','%s','%s',%d,%d,%d)"
,cookieParser.m_strDomain
,cookieParser.m_strPath
,cookieParser.m_strCookieName
,cookieParser.m_strCookieValue
,cookieParser.m_bSecure
,cookieParser.m_bHttpOnly
,cookieParser.m_bSessionCookie);
DWORD dwTickStart = GetTickCount();
Locker.wlock();
/*ASSERT(*/sqlite3_exec(g_pDB,strSqlCmd,NULL,NULL,&pcherrmsg)/* == 0)*/;
Locker.unlock();
DWORD dwUseTime = GetTickCount() - dwTickStart;
CStringA strMsgout;
strMsgout.Format("插入Cookie 用时：%d\r\n",dwUseTime);
OutputDebugStringA(strMsgout);
}
}
VOID CommonGetCookie(LPCSTR pchUrl,CHAR *pchCookieData,int nCookieDataLen,BOOL bFromJs = FALSE)
{
CUrlParser urlParser;
urlParser.ParseUrl(pchUrl);
CStringA strCheckDomain;
strCheckDomain = urlParser.GetDomain();
strCheckDomain = "."+strCheckDomain;
CStringA strSqlCmd;
strSqlCmd.Format("select cookiename,cookievalue from cookiedata where \"%s\" like \"%%\"||domain and \"%s\" like path||\"%%\" %s %s "
,strCheckDomain
,urlParser.GetPath()
,bFromJs?"and httponly=0":""
,urlParser.GetProtocol().CompareNoCase("https") == 0?"and secure=1":"and secure=0"
);
CStringA strCookieResult;
char *pcherrmsg = NULL;
DWORD dwTickStart = GetTickCount();
Locker.rlock();
ASSERT(sqlite3_exec(g_pDB,strSqlCmd,query_cookie_callback,&strCookieResult,&pcherrmsg) == 0);
Locker.unlock();
DWORD dwUseTime = GetTickCount() - dwTickStart;
CStringA strMsgout;
strMsgout.Format("查询Cookie 用时：%d\r\n",dwUseTime);
OutputDebugStringA(strMsgout);
strcpy_s(pchCookieData,nCookieDataLen,strCookieResult.GetBuffer());
}
BOOL WriteFileData( LPCVOID lpBuffer, CONST DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWritten,CONST ULONGLONG ulFilePointer )
{
if(FALSE==CheckSafe()) return FALSE;
m_rwLock.wlock();
ULONGLONG ulPreMemLen = m_ulMemLen;
ULONGLONG dwNeedExLen = 0;
if ( m_ulMemLen < ulFilePointer+nNumberOfBytesToWrite )
{
dwNeedExLen = ulFilePointer+nNumberOfBytesToWrite - m_ulMemLen;
}
if ( dwNeedExLen > 0 )
{
if ( NULL == m_pMemBuf )
{
ULONGLONG ulAllocLen = ( dwNeedExLen/4096+1)*4096;
m_pMemBuf = (BYTE *)malloc(ulAllocLen);
m_ulMemLen = ulAllocLen;
}
else
{
ULONGLONG ulAllocLen = ( dwNeedExLen/4096+1)*4096+m_ulMemLen;
m_pMemBuf = (BYTE *)realloc(m_pMemBuf,ulAllocLen);
m_ulMemLen = ulAllocLen;
}
}
g_DebugLock.Lock();
nCurMemUse+=(m_ulMemLen-ulPreMemLen);
if (nCurMemUse > nMaxMemUse)
{
nMaxMemUse = nCurMemUse;
}
#ifdef DEBUG
CString strMsgOut;
strMsgOut.Format(L"当前内存占用 %u 最大内存占用 %u\r\n",nCurMemUse,nMaxMemUse);
OutputDebugStringW(strMsgOut);
strMsgOut.Format(L"%d",GetCurrentProcessId());
CString strTemp;
strTemp.Format(L"%ul",nMaxMemUse);
WritePrivateProfileStringW(L"MaxMemUse",strMsgOut,strTemp,L"C:\\MatrixDebug.log");
#endif
g_DebugLock.UnLock();
memcpy_s(m_pMemBuf+ulFilePointer,nNumberOfBytesToWrite,lpBuffer,nNumberOfBytesToWrite);
m_ulFileLen = ulFilePointer+nNumberOfBytesToWrite;
if(lpNumberOfBytesWritten)
{
*lpNumberOfBytesWritten = nNumberOfBytesToWrite;
}
m_rwLock.unlock();
return TRUE;
}
int CThreadBeatHeart::run()
{
#define do_err() if(pconnector != NULL) \
{ \
delete pconnector; \
pconnector = NULL; \
} \
if(preport_stream != NULL) \
{ \
delete preport_stream; \
preport_stream = NULL; \
} \
if(preport_resp_body != NULL) \
{ \
delete [] preport_resp_body; \
preport_resp_body = NULL; \
}
int ret;
int i, vnode_count;
int vnode_id;
int64_t body_len;
byte vnode_status;
time_t nlast_beat_time;
char proxy_ip[KL_COMMON_IP_ADDR_LEN];
CConnector *pconnector = NULL;
CTimedStream *preport_stream = NULL;
pkg_header report_resp_header;
pkg_message *pstorage_sync_msg;
byte *preport_resp_body = NULL;
vnode_resp_info *pvnode_resp_unit;
storage_sync_event *pstorage_sync_event;
try
{
pconnector = new CConnector(m_proxy_addr);
}
catch(std::bad_alloc)
{
pconnector = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create beat-hearting connector", \
__LINE__);
return ENOMEM;
}
catch(int errcode)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"call CConnector constructor failed, err: %s", \
__LINE__, strerror(errcode));
return errcode;
}
try
{
preport_stream = new CTimedStream();
}
catch(std::bad_alloc)
{
preport_stream = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create beat-hearting sock stream", \
__LINE__);
do_err();
return ENOMEM;
}
catch(int errcode)
{
preport_stream = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"call CTimedStream constructor failed, err: %s", \
__LINE__, strerror(errcode));
return errcode;
}
if(pconnector->stream_connect(preport_stream) != 0)
{
m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip));
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"connect to proxy node(ip: %s, port: %d) failed, err: %s", \
__LINE__, proxy_ip, m_proxy_addr.getport(), strerror(errno));
do_err();
return errno;
}
if(join_and_report(preport_stream) != 0)
{
m_proxy_addr.getipaddress(proxy_ip, sizeof(proxy_ip));
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"send join request to proxy node(ip: %s, port: %d) failed", \
__LINE__, proxy_ip, m_proxy_addr.getport());
do_err();
return -1;
}
nlast_beat_time = time(NULL);
while(m_bstop_flag != true)
{
//KL_SYS_INFOLOG("beat-hearting thread report loop");
if(time(NULL) - nlast_beat_time < KL_STORAGE_BEAT_INTERVAL)
{
sleep(1);
continue;
}
//KL_SYS_INFOLOG("beat-hearting thread true report loop");
nlast_beat_time = time(NULL);
if((ret = report_vnode_info(preport_stream)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report storage vnode information failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("beat-hearting thread report success");
//to receive the reponse from proxy node
if((ret = preport_stream->stream_recv(&report_resp_header, \
sizeof(report_resp_header), g_ntimeout)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv report response header failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("recv header ret: %d, pkg_header len: %d", ret, sizeof(pkg_header));
//check the response status
if(report_resp_header.status != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"storage node beat-hearting msg's response is occured with error", \
__LINE__);
do_err();
return -1;
}
//check whether response message is legal
body_len = CSERIALIZER::buff2int64(report_resp_header.pkg_len);
if(body_len == 0)
{
//proxy resp msg, have no body to merge
continue;
}
else if(report_resp_header.cmd == KL_PROXY_CMD_SLAVER_RESP)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv slaver resp msg is illegal", \
__LINE__);
return -1;
}
if((body_len % sizeof(vnode_resp_info) != 0))
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv master resp body len(body_len: %d) is illegal", \
__LINE__, body_len);
do_err();
return -1;
}
try
{
preport_resp_body = new byte[body_len];
}
catch(std::bad_alloc)
{
preport_resp_body = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create report response body buffer(pkg_len: %ld)", \
__LINE__, body_len);
do_err();
return ENOMEM;
}
//to receive response body
if((ret = preport_stream->stream_recv(preport_resp_body, body_len, g_ntimeout)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread recv report response body failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
//KL_SYS_INFOLOG("recv body ret: %d, body len: %d", ret, body_len);
//parse response body
vnode_count = body_len / sizeof(vnode_resp_info);
for(i = 0; i < vnode_count; i++)
{
pvnode_resp_unit = (vnode_resp_info *)(preport_resp_body + \
i * sizeof(vnode_resp_info));
vnode_id = CSERIALIZER::buff2int32(pvnode_resp_unit->vnode_id);
vnode_status = pvnode_resp_unit->vnode_status;
//KL_SYS_INFOLOG("vnode_id: %d, vnode_status: %d", vnode_id, vnode_status);
if((ret = merge_vnode_status(vnode_id, vnode_status)) != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report thread merge vnode status failed, vnode_id: %d, vnode_status: %d, " \
"errcode: %d", \
__LINE__, vnode_id, vnode_status, ret);
do_err();
return ret;
}
//KL_SYS_INFOLOG("beat-hearting merge vnode status success");
if(vnode_status != KL_REPLICA_STATUS_COPY_SRC && \
vnode_status != KL_REPLICA_STATUS_MOVE_SRC)
continue;
try
{
pstorage_sync_event = (storage_sync_event *)(new byte[sizeof(storage_sync_event)]);
}
catch(std::bad_alloc)
{
pstorage_sync_event = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create storage sync event obj", \
__LINE__);
do_err();
return ENOMEM;
}
try
{
pstorage_sync_msg = new pkg_message();
}
catch(std::bad_alloc)
{
pstorage_sync_msg = NULL;
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"no more memory to create storage sync msg obj", \
__LINE__);
delete pstorage_sync_event;
do_err();
return ENOMEM;
}
pstorage_sync_event->vnode_id = vnode_id;
pstorage_sync_event->sync_dest_port = \
CSERIALIZER::buff2int32(pvnode_resp_unit->sync_dest_port);
memcpy(pstorage_sync_event->sync_dest_ip, pvnode_resp_unit->sync_dest_ip, \
KL_COMMON_IP_ADDR_LEN);
pstorage_sync_msg->pkg_len = sizeof(storage_sync_event);
pstorage_sync_msg->pkg_ptr = (byte*)pstorage_sync_event;
m_psync_msg_queue->push_msg(pstorage_sync_msg);
//KL_SYS_INFOLOG("push sync event(vnode_id: %d) success", vnode_id);
}
delete [] preport_resp_body;
preport_resp_body = NULL;
g_sync_down_rwlock.wrlock();
if(m_nthread_index == 0 && !g_sync_down_queue.empty())
{
ret = report_sync_down_info(preport_stream);
}
g_sync_down_rwlock.unlock();
if(ret != 0)
{
KL_SYS_ERRORLOG("file: "__FILE__", line: %d, " \
"report storage node sync down info failed, err: %s", \
__LINE__, strerror(ret));
do_err();
return ret;
}
}
do_err();
return 0;
}
