CLStatus CLLogger::WriteMsgAndErrcodeToFile(const char* pstrMsg, const char* pstrErrcode) {
if(m_nUsedBytesForBuffer != 0) {
if(write(m_fd, m_pLogBuffer, m_nUsedBytesForBuffer) == -1)
return CLStatus(-1,0);
m_nUsedBytesForBuffer = 0;
}
if(write(m_fd, pstrMsg, strlen(pstrMsg)) == -1)
return CLStatus(-1,0);
if(write(m_fd, pstrErrcode, strlen(pstrErrcode)) == -1)
return CLStatus(-1,0);
return CLStatus(0,0);
}
CLStatus CLConditionVariable::WakeupAll()
{
int r = pthread_cond_broadcast(m_pConditionVariable);
if(r != 0)
{
CLLogger::WriteLogMsg("In CLConditionVariable::WakeupAll, pthread_cond_broadcast error", r);
return CLStatus(-1, 0);
}
else
{
return CLStatus(0, 0);
}
}
CLStatus CLThread::Run(void *pContext)
{
m_pContext = pContext;
int r = pthread_create(&m_ThreadID, 0, StartFunctionOfThread, this);
if(r != 0)
{
CLLogger::WriteLogMsg("In CLThread::Run(), pthread_create error", r);
return CLStatus(-1, 0);
}
return CLStatus(0, 0);
}
CLStatus CLConditionVariable::Wakeup()
{
int r = pthread_cond_signal(m_pConditionVariable);
if(r != 0)
{
CLLogger::WriteLogMsg("In CLConditionVariable::Wakeup, pthread_cond_signal error", r);
return CLStatus(-1, 0);
}
else
{
return CLStatus(0, 0);
}
}
CLStatus CLLogger::writeLog(const char *msg, long errorCode){
if(msg == 0)
return CLStatus(-1,0);
if(strlen(msg) == 0)
return CLStatus(-1,0);
if(fileFd == -1)
return CLStatus(-1,0);
//带缓冲区的日志类代码实现
unsigned int nLeftRoom = BUFFER_SIZE_LOG_FILE - usedByteForBuffer;
unsigned int lengthOfMsg = strlen(msg);
char buf[MAX_LINE];
snprintf(buf,MAX_LINE," Error code:%d\r\n",errorCode);
unsigned int lengthOfCode = strlen(buf);
unsigned int totalLen = lengthOfMsg + lengthOfCode;
if(totalLen > BUFFER_SIZE_LOG_FILE){
CLStatus s = flush();
if(!s.isSuccess())
return CLStatus(-1,0);
ssize_t r = write(fileFd,msg,lengthOfMsg);
if(r == -1)
return CLStatus(-1,errno);
r = write(fileFd,buf,lengthOfCode);
if(r == -1)
return CLStatus(-1,errno);
}
if(totalLen > nLeftRoom){
CLStatus s = flush();
if(!s.isSuccess())
return CLStatus(-1,0);
}
memcpy(logBuffer + usedByteForBuffer,msg,lengthOfMsg);
usedByteForBuffer += lengthOfMsg;
memcpy(logBuffer + usedByteForBuffer,buf,lengthOfCode);
usedByteForBuffer += lengthOfCode;
/*不带缓冲区的日志类代码实现。
* ssize_t n = write(fileFd,msg,strlen(msg));
if(n < 0)
return CLStatus(-1,errno);
char buf[MAX_LINE];
snprintf(buf,MAX_LINE," Error code:%d\r\n",errorCode);
n = write(fileFd, buf, strlen(buf));
if(n < 0){
return CLStatus(-1,errno);
}*/
return CLStatus(0,0);
}
CLStatus CLListenAgent::receiveData(){
socklen_t clientLen;
int clientFd;
clientFd = accept( listenFd, (struct sockaddr*)&clientAddr, &clientLen );
if(clientFd < 0){
CLLogger::writeLogMessage( "CLListen:: receiveData accept error!\n",errno );
return CLStatus( FAILED,errno );
}
CLAgent *jobAgent = new CLJobAgent(clientFd);
CLEpoll::getInstance() -> doEvent(jobAgent,clientFd,EPOLL_CTL_ADD,EPOLLIN);
return CLStatus( SUCCESSFUL,0 );
}
CLStatus On_1(CLMessage *pm)
{
CLMsg1ForCLNonThreadForMsgLoop *p = dynamic_cast<CLMsg1ForCLNonThreadForMsgLoop*>(pm);
EXPECT_TRUE(p != 0);
g_for_on1++;
if(g_for_on1 == count)
{
pthread->WaitForDeath();
return CLStatus(QUIT_MESSAGE_LOOP, 0);
}
else
return CLStatus(0, 0);
}
CLStatus CLMsgLoopManagerForPipeQueue::Uninitialize()
{
CLPrivateMsgQueuebyNamedPipe *pQueue = dynamic_cast<CLPrivateMsgQueuebyNamedPipe *>(m_pMsgQueue);
if(pQueue == 0)
return CLStatus(0, 0);
CLExecutiveNameServer *pNameServer = CLExecutiveNameServer::GetInstance();
if(pNameServer == 0)
{
CLLogger::WriteLogMsg("In CLMsgLoopManagerForPipeQueue::Uninitialize(), CLExecutiveNameServer::GetInstance error", 0);
return CLStatus(-1, 0);
}
return pNameServer->ReleaseCommunicationPtr(m_strThreadName.c_str());
}
CLStatus CLMessageLoopManager::DispatchMessage(CLMessage* pMessage)
{
std::map<unsigned long,CallBackForMessageLoop>::iterator iter;
iter = m_MsgMappingTable.find(pMessage->m_clMsgID);
if(iter == m_MsgMappingTable.end())
{
CLLogger::WriteLogMesg("In CLMessageLoopManager::DispatchMessage(), it == m_MsgMappingTable.end", 0);
return CLStatus(-1, 0);
}
CallBackForMessageLoop pFunction = iter->second;
if(pFunction != 0)
return (m_pMessageOberver->*pFunction)(pMessage);
else
return CLStatus(-1,0);
}
CLStatus CLLogger::WriteLog(const char *pstrMsg, long lErrorCode)
{
if(pstrMsg == 0)
return CLStatus(-1, 0);
if(strlen(pstrMsg) == 0)
return CLStatus(-1, 0);
if(m_pLogBuffer == 0)
return CLStatus(-1, 0);
unsigned int nleftroom = BUFFER_SIZE_LOG_FILE - m_nUsedBytesForBuffer;
unsigned int len_strmsg = strlen(pstrMsg);
char buf[MAX_SIZE];
snprintf(buf, MAX_SIZE, " Error code: %ld\r\n", lErrorCode);
unsigned int len_code = strlen(buf);
unsigned int total_len = len_code + len_strmsg;
if(total_len > BUFFER_SIZE_LOG_FILE)
{
if(m_Fd == -1)
return CLStatus(-1, 0);
ssize_t r = write(m_Fd, pstrMsg, len_strmsg);
if(r == -1)
return CLStatus(-1, errno);
r = write(m_Fd, buf, len_code);
if(r == -1)
return CLStatus(-1, errno);
return CLStatus(0, 0);
}
if(total_len > nleftroom)
{
CLStatus s = Flush();
if(!s.IsSuccess())
return CLStatus(-1, 0);
}
memcpy(m_pLogBuffer + m_nUsedBytesForBuffer, pstrMsg, len_strmsg);
m_nUsedBytesForBuffer += len_strmsg;
memcpy(m_pLogBuffer + m_nUsedBytesForBuffer, buf, len_code);
m_nUsedBytesForBuffer += len_code;
return CLStatus(0, 0);
}
virtual CLStatus Initialize(CLMessageLoopManager *pMessageLoop, void* pContext)
{
pMessageLoop->Register(1, (CallBackForMessageLoop)(&CLObserverTesterForCLMsgLoopManagerForShareNamedPipe::On_1));
pMessageLoop->Register(2, (CallBackForMessageLoop)(&CLObserverTesterForCLMsgLoopManagerForShareNamedPipe::On_2));
return CLStatus(0, 0);
}
CLStatus CLConditionVariable::Wait(CLMutex *pMutex)
{
if(pMutex == NULL)
return CLStatus(-1, 0);
int r = pthread_cond_wait(&m_ConditionVariable, pMutex->m_pMutex);
if(r != 0)
{
CLLogger::WriteLogMsg("In CLConditionVariable::Wait, pthread_cond_wait error", r);
return CLStatus(-1, 0);
}
else
{
return CLStatus(0, 0);
}
}
CLStatus On_2(CLMessage *pm)
{
CLMsg2ForCLNonThreadForMsgLoopTest *p = dynamic_cast<CLMsg2ForCLNonThreadForMsgLoopTest*>(pm);
EXPECT_TRUE(p != 0);
return CLStatus(QUIT_MESSAGE_LOOP, 0);
}
CLStatus CLThreadForMsgLoop::Ready(CLMessageObserver *pMsgObserver, const char *pstrThreadName,int ExecutiveType)
{
m_pCoordinator = new CLRegularCoordinator();
CLMessageLoopManager* pM;
if(ExecutiveType == EXECUTIVE_IN_PROCESS_USE_STL_QUEUE)
{
pM = new CLMsgLoopManagerForSTLqueue(pMsgObserver,pstrThreadName);
}
else if(ExecutiveType == EXECUTIVE_IN_PROCESS_USE_PIPE_QUEUE)
{
m_pPipeMsgQueue = new CLMsgLoopManagerForPipeQueue(pMsgObserver,pstrThreadName,PIPE_QUEUE_IN_PROCESS);
pM = m_pPipeMsgQueue;
}
else if(ExecutiveType == EXECUTIVE_BETWEEN_PROCESS_USE_PIPE_QUEUE)
{
m_pPipeMsgQueue = new CLMsgLoopManagerForPipeQueue(pMsgObserver,pstrThreadName,PIPE_QUEUE_BETWEEN_PROCESS);
pM = m_pPipeMsgQueue;
}
else
throw "In CLThreadForMsgLoop::Ready(), ExecutiveType error.";
CLExecutiveFunctionForMsgLoop *myadder = new CLExecutiveFunctionForMsgLoop(pM);
CLThread *pThread= new CLThread(m_pCoordinator, m_bWaitForDeath);
m_pCoordinator->SetExecObjects(pThread,myadder);
return CLStatus(0,0);
}
CLStatus CLThread::WaitForDeath()
{
if(!m_bThreadCreated)
return CLStatus(-1,0);
if(!m_bWaitForDeath)
return CLStatus(-1,0);
int r = pthread_join(m_ThreadID,0);
if(0 != r){
CLLogger::WriteLogMesg("In CLThread::WaitForDeath(), pthread_join error", r);
return CLStatus(-1,0);
}
//delete this;
return CLStatus(0,0);
}
virtual CLStatus Deserialize(CLIOVectors& IOVectors, CLMessage **ppMsg, CLBufferManager& BufferManager)
{
CLIteratorForIOVectors iter;
IOVectors.GetIterator(0, iter);
int len = 0;
EXPECT_TRUE(IOVectors.ReadBlock(iter, (char *)(&len), 4).IsSuccess());
EXPECT_EQ(len, 16);
long id = 0;
EXPECT_TRUE(IOVectors.ReadBlock(iter, (char *)(&id), 8).IsSuccess());
EXPECT_EQ(id, 1);
int x = 0;
EXPECT_TRUE(IOVectors.ReadBlock(iter, (char *)(&x), 4).IsSuccess());
EXPECT_EQ(x, 2);
int y = 0;
EXPECT_TRUE(IOVectors.ReadBlock(iter, (char *)(&y), 4).IsSuccess());
EXPECT_EQ(y, 3);
*ppMsg = new CLMsg1ForCLMsgLoopManagerForShareNamedPipeTest();
return CLStatus(0, 0);
}
CLStatus CLNonThreadForMsgLoop::RegisterDeserializer(unsigned long lMsgID, CLMessageDeserializer *pDeserializer)
{
if(m_pPipeMsgQueue != NULL)
return m_pPipeMsgQueue->RegisterDeserializer(lMsgID, pDeserializer);
return CLStatus(-1, 0);
}
CLStatus CLConditionVariable::Wait(CLMutex *pMutex)
{
if(pMutex == NULL)
return CLStatus(-1, 0);
int r = pthread_cond_wait(&m_ConditionVariable, ((CLMutexByPThread *)(pMutex->GetMutexInterface()))->GetMutexPointer());
if(r != 0)
{
CLLogger::WriteLogMsg("In CLConditionVariable::Wait, pthread_cond_wait error", r);
return CLStatus(-1, 0);
}
else
{
return CLStatus(0, 0);
}
}
CLStatus CLMessageQueueBySTLqueue::Push(CLMessage * pMessage)
{
try
{
CLCriticalSection cs(&m_Mutex);
m_MessageQueue.push(pMessage);
}
catch(const char* str)
{
CLLogger::WriteLogMsg("In CLMessageQueue::Push(), exception arise", 0);
return CLStatus(-1, 0);
}
return CLStatus(0, 0);
}
CLStatus CLMutexByRecordLockingAndPThread::Unlock()
{
if(!m_ProcessMutex.Unlock().IsSuccess())
{
CLLogger::WriteLogMsg("In CLMutexByRecordLockingAndPThread::Lock(), m_ProcessMutex.Unlock error", 0);
return CLStatus(-1, 0);
}
if(!m_ThreadMutex.Unlock().IsSuccess())
{
CLLogger::WriteLogMsg("In CLMutexByRecordLockingAndPThread::Lock(), m_ThreadMutex.Unlock error", 0);
return CLStatus(-1, 0);
}
return CLStatus(0, 0);
}
CLStatus CLMessageLoopManager::EnterMessageLoop(void *pContext)
{
CLStatus s = Initialize();
if(!s.IsSuccess())
{
CLLogger::WriteLogMsg("In CLMessageLoopManager::EnterMessageLoop(), Initialize error", 0);
return CLStatus(-1, 0);
}
CLStatus s1 = m_pMessageObserver->Initialize(this, pContext);
if(!s1.IsSuccess())
{
CLLogger::WriteLogMsg("In CLMessageLoopManager::EnterMessageLoop(), m_pMessageObserver->Initialize error", 0);
CLStatus s2 = Uninitialize();
if(!s2.IsSuccess())
CLLogger::WriteLogMsg("In CLMessageLoopManager::EnterMessageLoop(), Uninitialize() error", 0);
return CLStatus(-1, 0);
}
while(true)
{
CLMessage *pMsg = WaitForMessage();
if(pMsg == 0)
{
CLLogger::WriteLogMsg("In CLMessageLoopManager::EnterMessageLoop(), pMsg == 0", 0);
continue;
}
CLStatus s3 = DispatchMessage(pMsg);
delete pMsg;
if(s3.m_clReturnCode == QUIT_MESSAGE_LOOP)
break;
}
CLStatus s4 = Uninitialize();
if(!s4.IsSuccess())
{
CLLogger::WriteLogMsg("In CLMessageLoopManager::EnterMessageLoop(), Uninitialize() error", 0);
return CLStatus(-1, 0);
}
return CLStatus(0, 0);
}
CLStatus CLSharedEventAllocator::Release(const char *pstrEventName)
{
CLSharedEventAllocator *p = CLSharedEventAllocator::GetInstance();
if(p == 0)
return CLStatus(-1, 0);
return p->ReleaseEventInfo(pstrEventName);
}
CLStatus CLMsgLoopManagerForPipeQueue::RegisterDeserializer(unsigned long lMsgID, CLMessageDeserializer *pDeserializer)
{
CLSharedMsgQueueByNamedPipe *pQueue = dynamic_cast<CLSharedMsgQueueByNamedPipe *>(m_pMsgQueue);
if(pQueue != 0)
return pQueue->RegisterDeserializer(lMsgID, pDeserializer);
else
return CLStatus(-1, 0);
}
CLStatus CLSharedMsgQueueByNamedPipe::RegisterDeserializer(unsigned long lMsgID, CLMessageDeserializer *pDeserializer)
{
if(pDeserializer == 0)
return CLStatus(-1, 0);
map<unsigned long, CLMessageDeserializer*>::iterator it = m_DeserializerTable.find(lMsgID);
if(it != m_DeserializerTable.end())
{
delete pDeserializer;
CLLogger::WriteLogMsg("In CLMessageQueueByNamedPipe::RegisterDeserializer(), m_DeserializerTable.find error", 0);
return CLStatus(-1, 0);
}
m_DeserializerTable[lMsgID] = pDeserializer;
return CLStatus(0, 0);
}
CLStatus CLSharedExecutiveCommunicationByNamedPipe::RegisterSerializer(unsigned long lMsgID, CLMessageSerializer *pSerializer)
{
if(pSerializer == 0)
return CLStatus(-1, 0);
map<unsigned long, CLMessageSerializer*>::iterator it = m_SerializerTable.find(lMsgID);
if(it != m_SerializerTable.end())
{
delete pSerializer;
CLLogger::WriteLogMsg("In CLSharedExecutiveCommunicationByNamedPipe::RegisterSerializer(), m_SerializerTable.find error", 0);
return CLStatus(-1, 0);
}
m_SerializerTable[lMsgID] = pSerializer;
return CLStatus(0, 0);
}
CLStatus CLSharedEventAllocator::Create()
{
if(m_pAllocator == 0)
{
try
{
m_pAllocator = new CLSharedEventAllocator();
}
catch(const char *str)
{
CLLogger::WriteLogMsg(str, 0);
return CLStatus(-1, 0);
}
}
return CLStatus(0, 0);
}
CLStatus CLLogger::flush(){
if(fileFd == -1)
return CLStatus(-1,0);
if(logBuffer == 0)
return CLStatus(-1,0);
if(usedByteForBuffer == 0)
return CLStatus(0,0);
ssize_t r = write(fileFd,logBuffer,usedByteForBuffer);
if(r == -1)
return CLStatus(-1,errno);
usedByteForBuffer = 0;
return CLStatus(-1,0);
}
CLStatus CLConditionVariable::WakeupAll()
{
if(pthread_cond_broadcast(m_pConditionVariable)){
throw "In CLConditionVariable::WakeupAll(),pthread_cond_broadcast() error.";
CLLogger::WriteLogMesg("In CLConditionVariable::WakeupAll(),pthread_cond_broadcast() error.",0);
}
return CLStatus(0,0);
}
CLStatus CLLogger::flush() {
if(pthread_mutex_lock(m_pMutexForWriteLog) != 0)
return CLStatus(-1,0);
try{
if(m_fd == -1)
throw CLStatus(-1,0);
if(m_pLogBuffer == NULL)
throw CLStatus(-1,0);
if(m_nUsedBytesForBuffer == 0)
throw CLStatus(0,0);
ssize_t r = write(m_fd, m_pLogBuffer, m_nUsedBytesForBuffer);
if(r == -1)
throw CLStatus(-1, errno);
m_nUsedBytesForBuffer = 0;
throw CLStatus(0,0);
}
catch(CLStatus &s) {
if(pthread_mutex_unlock(m_pMutexForWriteLog) != 0)
return CLStatus(-1,0);
return s;
}
}
CLStatus On_2(CLMessage *pm)
{
CLMsg2ForCLThreadForMsgLoop *p = dynamic_cast<CLMsg2ForCLThreadForMsgLoop*>(pm);
EXPECT_TRUE(p != 0);
g_for_on2++;
return CLStatus(QUIT_MESSAGE_LOOP, 0);
}
