myvtm/Module/mod_MaintainWatcher/ukeytask.cpp

#include "stdafx2.h"
#include "SpBase.h"
#include "ukeytask.h"


extern int WINAPI gui_entry(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR lpstrCmdLine, int nCmdShow, HWND *phWnd, IConsole *pConsole);
#define OP_START_ENTITY		1
#define OP_STOP_ENTITY		0
#define OP_PAUSE_ENTITY		2
#define OP_TERMINATE_ENTITY 3
#define OP_CONTINUE_ENTITY	4
#define OP_FIRE_ENTITY_STATE		5

struct callback_entry : public IReleasable
{
	virtual ~callback_entry() {}
	CSimpleStringA EntityName;
	union {
		void *pRawData;
		int state;
	};
	int op;
	ErrorCodeEnum ErrorResult;
};

ErrorCodeEnum UKEYTask::CloseWindow()
{
	if (m_hWndMainFrame) {
		PostMessageA(m_hWndMainFrame, WM_CLOSE, -1, -1);
		WaitForSingleObject(m_hEventStopReady, INFINITE);
		return Error_Succeed;
	} else {
		return Error_NotInit;
	}
}

ErrorCodeEnum UKEYTask::WaitWindowCreated()
{
	WaitForSingleObject(m_hEventStartReady, INFINITE);
	return Error_Succeed;
}

void UKEYTask::Process()
{
	{
		m_pEntity->GetFunction()->InitLogCurrentThread();
	}
	gui_entry(ModuleBase::GetModuleBase()->GetInstance(), NULL, NULL, SW_SHOW, &m_hWndMainFrame, this);
	m_hWndMainFrame = NULL;
}

ErrorCodeEnum UKEYTask::Initialize()
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		//ErrorCodeEnum Error = pFuncPrivilege->RegistEntityStateEvent(NULL, this); // NULL to register for all
		//if (Error == Error_Succeed) {
		//	ResetEvent(m_hEventStartReady);
		//	ResetEvent(m_hEventStopReady);
		//	LOG_ASSERT(m_pSink == NULL);
		//}
		//return Error;
			return Error_Succeed;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum UKEYTask::UnInitialize()
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		ErrorCodeEnum Error = pFuncPrivilege->UnregistEntityStateEvent(NULL);
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

void UKEYTask::OnStartRead(BOOL bOk)
{
	SetEvent(m_hEventStartReady);
}

void UKEYTask::OnStopReady()
{
	SetEvent(m_hEventStopReady);
}

ErrorCodeEnum UKEYTask::ReqFrameworkQuit()
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) 
	{
		return pFuncPrivilege->Reboot(RebootTrigger_ManualLocal, RebootWay_Framework);
	}

	return Error_Unexpect;
}

ErrorCodeEnum UKEYTask::AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StartEntity(entity_name, cmdline, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_START_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum UKEYTask::AsyncStopEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StopEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_STOP_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum UKEYTask::GetAllEntity(CAutoArray<EntityEntry> &Entities)
{
	CSmartPointer<IEntityFunction> spFunc = m_pEntity->GetFunction();
	CAutoArray<CSimpleStringA> strEntityNames;
	CAutoArray<WORD> wDevelopIDs;
	ErrorCodeEnum Error = spFunc->GetAllRegistedEntity(strEntityNames, wDevelopIDs);
	if (Error == Error_Succeed) {
		Entities.Init(strEntityNames.GetCount());
		for (int i = 0; i < strEntityNames.GetCount(); ++i) {
			Error = GetEntity(strEntityNames[i], Entities[i]);
		}
	}
	return Error;
}

ErrorCodeEnum UKEYTask::GetEntity(const char *entity_name, EntityEntry &e)
{
	CSmartPointer<IEntityFunction> spFunc = m_pEntity->GetFunction();
	LOG_ASSERT(spFunc != NULL);
	CEntityStaticInfo StaticInfo;
	CEntityRunInfo RunInfo;
	ErrorCodeEnum Error = spFunc->GetEntityStaticInfo(entity_name, StaticInfo);
	if (Error == Error_Succeed) {
		Error = spFunc->GetEntityRunInfo(entity_name, RunInfo);
		if (Error == Error_Succeed) {
			e.Name = entity_name;
			e.Id = RunInfo.dwEntityInstanceID;
			e.ModuleName = _GetFileName(StaticInfo.strSpFileName);
			e.State = RunInfo.eState;
			e.Type = StaticInfo.bStartedByShell ? EE_AUTO : EE_MANUAL;
			e.Pid = (int)RunInfo.dwProcessID;
			e.DevelopID = (int)StaticInfo.wEntityDevelopID;
		}
	}
	return Error;
}

//ErrorCodeEnum UKEYTask::GetCustomizeStartMenuList(CAutoArray<StartMenuEntry> &StartItems)
//{
//	CSmartPointer<IEntityFunction> spFunc = m_pEntity->GetFunction();
//	CSmartPointer<IConfigInfo> spConfig;
//	LOG_ASSERT(spFunc != NULL);
//	int cnt = 0;
//	ErrorCodeEnum Error = spFunc->OpenConfig(Config_Software, spConfig);
//	if (Error != Error_Succeed)
//		return Error;
//	Error = spConfig->ReadConfigValueInt("StartMenu", "Number", cnt);
//	if (Error != Error_Succeed)
//		return Error;
//	StartItems.Init(cnt);
//	for (int i = 0; i < cnt; ++i) {
//		char tmp[128];
//		CSimpleStringA strValue;
//		_itoa(i+1, tmp, 10);
//		Error = spConfig->ReadConfigValue("StartMenu", tmp, strValue);
//		const char *p = strValue;
//		if (Error != Error_Succeed || p == NULL || strValue.GetLength() == 0)
//			break;
//		int kk = 0;
//		while (*p && *p != ' ') {
//			tmp[kk++] = *p;
//			p++;
//		}
//		tmp[kk] = 0;
//		StartItems[i].strEntity = tmp;
//		while (*p && *p == ' ')
//			p++;
//		if (*p) {
//			StartItems[i].strCmdLine = p;
//		} else {
//			StartItems[i].strCmdLine = "";
//		}
//	}
//	return Error;
//}

void UKEYTask::OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp)
{
	if (m_hWndMainFrame) {
		CSmartPointer<ICallbackListener> spCallback;
		CSmartPointer<IReleasable> pData;
		pAsynWaitSp->GetCallback(spCallback, pData);
		LOG_ASSERT(pData.GetRawPointer() != NULL);
		callback_entry *entry = static_cast<callback_entry*>((IReleasable*)pData.GetRawPointer());
		entry->ErrorResult = pAsynWaitSp->AsyncGetAnswer();
		callback_entry *new_entry = new callback_entry();
		new_entry->EntityName = entry->EntityName;
		new_entry->ErrorResult = entry->ErrorResult;
		new_entry->op = entry->op;
		new_entry->state = entry->state;
		PostMessage(m_hWndMainFrame, WM_GUICONSOLE, 0, (LPARAM)new_entry);
	}
}

UKEYTask::UKEYTask() : m_pEntity(NULL), m_hWndMainFrame(NULL),m_hThread(NULL)
{
	m_hEventStartReady = ::CreateEventA(NULL, TRUE, FALSE, NULL);
	m_hEventStopReady = ::CreateEventA(NULL, TRUE, FALSE, NULL);
}

UKEYTask::~UKEYTask()
{
	CloseHandle(m_hEventStopReady);
	CloseHandle(m_hEventStartReady);
}

ErrorCodeEnum UKEYTask::Kickoff()
{
	if (m_hThread) {
		return Error_Duplication;
	}
	m_hThread = (HANDLE)_beginthreadex(0, 0, &__Process, this, 0, 0);
	if (!m_hThread) {
		return Error_Resource;
	}
	return  Error_Succeed;
}

ErrorCodeEnum UKEYTask::OutputMsg(const char *pMsg)
{
	char *pBuf = new char[strlen(pMsg)+1];
	strcpy(pBuf, pMsg);
	PostMessage(m_hWndMainFrame, WM_SHOWDEBUGMSG, 0, (LPARAM)pBuf);
	return Error_Succeed;
}

ErrorCodeEnum UKEYTask::Close()
{
	if (!m_hThread) {
		return Error_NotInit;
	}
	WaitForSingleObject(m_hThread, INFINITE);
	return Error_Succeed;
}