mytaskscheduler.cpp

SQLBig5BugTool 宽字符操作问题

// MyTaskScheduler.cpp: implementation of the CMyTaskScheduler class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include <afxdb.h>

#include "MyTaskScheduler.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//max lock time : 5 minutes
//#define MAX_LAST_TASK_INFO_LOCK_TIME 1*60 //

IMyTaskScheduler* CreateTaskScheduler(
									  ITaskSchedulerEventSink*	ITaskSchedulerEventSink,
									  const char*				pszSchedulerID
									  )
{
	return new CMyTaskScheduler(ITaskSchedulerEventSink,pszSchedulerID);
}

CMyTaskScheduler::CMyTaskScheduler(
								   ITaskSchedulerEventSink*	ITaskSchedulerEventSink,
								   const char*				pszSchedulerID
								   ):
m_strSchedulerID(pszSchedulerID)
,m_pITaskSchedulerEventSink(ITaskSchedulerEventSink)
{
	m_dwLastDoTaskTick=0;
	
}

CMyTaskScheduler::~CMyTaskScheduler()
{	
	ClearAllTask();
}

void CMyTaskScheduler::Release()
{
	delete this;
}

IMyTask* CMyTaskScheduler::CreateNewTaskInternal(
												 const DWORD		dwTaskID,	
												 const DWORD		dwTaskDelayOrTime,
												 const bool			bScheduleImmediately,
												 const bool			bUserTask,
												 const DELAY_MODE	DelayMode
												 )
{
	if(bUserTask)
	{
		if(TASKID_USER_BASE>dwTaskID)
		{
			assert(false);
			return 0;
		}
	}
	else
	{
		if(TASKID_USER_BASE<=dwTaskID)
		{
			assert(false);
			return 0;
		}
	}
	
	CMyTask* pMyTask=new CMyTask(dwTaskID,dwTaskDelayOrTime,bScheduleImmediately,DelayMode);
	
	CSingleLock lck(&m_csLock,TRUE);
	
	m_MyTaskListNotScheduled.push_back(pMyTask);
	
	if(bScheduleImmediately)
	{
		ScheduleTask(pMyTask);
	}
	return pMyTask;
}

IMyTask* CMyTaskScheduler::ScheduleTaskEx(
										  const DWORD		dwTaskID,	
										  const DWORD		dwTaskDelayOrTime,
										  CParameterStruct*	pParameterStruct,
										  const DELAY_MODE	DelayMode
										  )
{
	if(pParameterStruct)
	{
		IMyTask* pIMyTask=CreateNewTask(
			dwTaskID,dwTaskDelayOrTime,false,DelayMode
			);	
		
		pParameterStruct->SetToParameterList(pIMyTask->GetIParameterList());
		
		ASSERT(pIMyTask->GetIParameterList()->GetParamCount()>0);
		
		ScheduleTask(pIMyTask);	
		
		return pIMyTask;
	}
	else
	{
		return CreateNewTask(
			dwTaskID,dwTaskDelayOrTime,true,DelayMode
			);	
	}
	
}

IMyTask* CMyTaskScheduler::CreateNewTask(
										 const DWORD		dwTaskID,	
										 const DWORD		dwTaskDelayOrTime,
										 const bool			bScheduleImmediately,//true:no parameter needed false:nedd more parameter so just schedule later
										 const DELAY_MODE	DelayMode
										 )
{
	return CreateNewTaskInternal(dwTaskID,dwTaskDelayOrTime,
		bScheduleImmediately,true,DelayMode);
}

void CMyTaskScheduler::ScheduleTask(IMyTask* pMyTask)
{
	CSingleLock lck(&m_csLock,TRUE);
	
	MYTASK_LIST::iterator itr2=std::find(m_MyTaskList.begin(),m_MyTaskList.end(),pMyTask);
	if(itr2!=m_MyTaskList.end())
	{		
		WRITE_APP_LOGEX("syslog/exception.log","ScheduleTask twice.0x%x",
			pMyTask
			);
		ASSERT(false);
		return;
	}

	MYTASK_LIST::iterator itr=std::find(m_MyTaskListNotScheduled.begin(),m_MyTaskListNotScheduled.end(),pMyTask);
	if(m_MyTaskListNotScheduled.end()==itr)
	{
		WRITE_APP_LOGEX("syslog/exception.log","task not in TaskListNotScheduled .0x%x",
			pMyTask
			);
		ASSERT(false);
		return;
	}

	m_MyTaskListNotScheduled.erase(itr);		

	m_MyTaskList.push_back(pMyTask);
	
	
	std::string strExceptionInfo;	
	try
	{
		if(m_pITaskSchedulerEventSink)
		{
			m_pITaskSchedulerEventSink->OnTaskScheduled(pMyTask);
		}
	}
	catch(CDBException* e)
	{
		strExceptionInfo=FormatString(
			"strError:<%s> nRetCode:%d strStateNativeOrigin:<%s>",
			e->m_strError,
			e->m_nRetCode,
			e->m_strStateNativeOrigin
			);
		e->Delete();
	}
	catch(...)
	{
		strExceptionInfo="Unknown";
	}
	if(!strExceptionInfo.empty())
	{
		WRITE_APP_LOGEX("syslog/exception.log","DoTask Exception. %d:%s.strExceptionInfo:%s",
			__LINE__,__FILE__,strExceptionInfo.c_str());
	}
}

BOOL CMyTaskScheduler::DoTaskInternal(IMyTask* pTaskInfo)
{
	if(pTaskInfo->IsUserTask())
	{
		return FALSE;
	}
	const DWORD dwTaskID=pTaskInfo->GetTaskID();
	switch(dwTaskID)
	{
	case TASK_SCHEDULER_PAUSE:
		{
			//			ULONG ulMS=pTaskInfo->GetIParameterList()->GetParamValueLONG("ulMS");
			//			ASSERT(ulMS>0);
			
			//Sleep(ulMS);
			
			return TRUE;
		}
		break;
	default:
		{
		}
		break;
	}
	
	return FALSE;
}

void CMyTaskScheduler::ProcessTask()
{
	CSingleLock lck(&m_csLock,TRUE);
	
	IMyTask* pTaskInfo=0;
	
	for(MYTASK_LIST::iterator itr=m_MyTaskList.begin();itr!=m_MyTaskList.end();itr++)
	{
		pTaskInfo=(*itr);
		m_MyTaskList.erase(itr);
		break;
	}	
	lck.Unlock();

	if(!pTaskInfo)
	{
		return;
	}
		BOOL bDoTask=FALSE;
		
		const DELAY_MODE DelayMode=pTaskInfo->GetDelayMode();
		
		switch(DelayMode)
		{
		case DELAYRUN_AT_SPECIFIC_TIME:
			if(time(0)>=pTaskInfo->GetTaskDelayOrTime())
			{
				bDoTask=TRUE;
			}
			break;
			
		case DELAYRUN_MS_RELATIVE_TO_DIPOSITED_TIME:
			if(GetTickCount()>=(pTaskInfo->GetTaskDepositeTick()+pTaskInfo->GetTaskDelayOrTime()))
			{
				bDoTask=TRUE;
			}
			break;
			
		case DELAYRUN_MS_RELATIVE_TO_FORMER_TASK:
			if(GetTickCount()>=(m_dwLastDoTaskTick+pTaskInfo->GetTaskDelayOrTime()))
			{
				bDoTask=TRUE;
			}
			break;
			
		default:
			assert(false);
			break;
		}
		
		if(!bDoTask)
		{
			return ;
		}
		std::string strExceptionInfo;
		try
		{
			if(!pTaskInfo->IsUserTask())
			{
				DoTaskInternal(pTaskInfo);
			}
		}
		catch(CDBException* e)
		{
			strExceptionInfo=FormatString(
				"strError:<%s> nRetCode:%d strStateNativeOrigin:<%s>",
				e->m_strError,
				e->m_nRetCode,
				e->m_strStateNativeOrigin
				);
			e->Delete();
		}
		catch(...)
		{
			strExceptionInfo="Unknown";
		}			
		if(!strExceptionInfo.empty())
		{
			WRITE_APP_LOGEX("syslog/exception.log","DoTaskInternal Exception. %d:%s.strExceptionInfo:%s",
				__LINE__,__FILE__,strExceptionInfo.c_str());
		}
		
		try
		{
			if(m_pITaskSchedulerEventSink)
			{
				m_pITaskSchedulerEventSink->DoTask(pTaskInfo);
			}
		}
		catch(CDBException* e)
		{
			strExceptionInfo=FormatString(
				"strError:<%s> nRetCode:%d strStateNativeOrigin:<%s>",
				e->m_strError,
				e->m_nRetCode,
				e->m_strStateNativeOrigin
				);
			e->Delete();
		}
		catch(...)
		{
			strExceptionInfo="Unknown";
		}
		if(!strExceptionInfo.empty())
		{
			WRITE_APP_LOGEX("syslog/exception.log","DoTask Exception. %d:%s.strExceptionInfo:%s",
				__LINE__,__FILE__,strExceptionInfo.c_str());
		}
		
		if(TASK_SCHEDULER_PAUSE==pTaskInfo->GetTaskID())
		{
		}
		else
		{
			delete ((CMyTask*)pTaskInfo);
			
			m_dwLastDoTaskTick=GetTickCount();				
		}
}

void CMyTaskScheduler::ClearAllTask()
{
	CSingleLock lck(&m_csLock,TRUE);

	for(MYTASK_LIST::iterator itr=m_MyTaskList.begin();itr!=m_MyTaskList.end();itr++)
	{
		IMyTask* pTaskInfo=(*itr);
		delete ((CMyTask*)pTaskInfo);
	}
	
	for(MYTASK_LIST::iterator itr2=m_MyTaskListNotScheduled.begin();
	itr2!=m_MyTaskListNotScheduled.end();itr2++)
	{
		IMyTask* pTaskInfo=(*itr2);
		delete ((CMyTask*)pTaskInfo);		
	}	
}

void CMyTaskScheduler::ClearTasks()
{
	ClearAllTask();
}

void CMyTaskScheduler::TaskSchedulerPause(const ULONG ulMS)
{
	IMyTask* pIMyTask=CreateNewTaskInternal(
		TASK_SCHEDULER_PAUSE,
		ulMS,
		false,
		false,
		DELAYRUN_MS_RELATIVE_TO_FORMER_TASK
		);
	
	pIMyTask->GetIParameterList()->SetParamValueLONG("ulMS",ulMS);
	
	ScheduleTask(pIMyTask);
}

const char* CMyTaskScheduler::GetTaskName(const DWORD dwTaskID)
{
	switch(dwTaskID)
	{	
	case TASK_SCHEDULER_PAUSE:
		{
			return "TASK_SCHEDULER_PAUSE";
		};
		break;
	}
	return "TaskID Unknown";
}