myvtm/Module/mod_ups/UpsFSM.cpp

#include "stdafx.h"
#include "UpsFSM.h"
#include "GetDevInfoHelper.h"
const int MAX_UPS_INIT_TRIES = 3;

ErrorCodeEnum CUpsFSM::OnInit()
{
    LOG_FUNCTION();
    GET_DEV_ENTITY_BASE_POINTER()->InitializeVendorLogSwitch();
    CSimpleStringA dllName;
    auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
    auto result = pEntity->ExtractVendorLibFullPath(dllName);
    if (result != Error_Succeed) {
        return result;
    }
    HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, pEntity->vendorLibInfo.strVendor);
    Dbg("vendor library path: %s", (LPCTSTR)dllName);
	m_adapterInfo.adapterFileName = dllName;
    result = m_hDevHelper.LoadUp(dllName);
    if (result != Error_Succeed) {
        return result;
    }
    CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
    CSmartPointer<IConfigInfo> spConfig;
	result = spEntityFunction->OpenConfig(Config_Root, spConfig);
    if (result != Error_Succeed) {
        Dbg("open cfg file failed!");
        return result;
    }

    int baudRate = 0, port = 0;
    spConfig->ReadConfigValueInt("Device.Ups", "Baudrate", baudRate);
    spConfig->ReadConfigValueInt("Device.Ups", "Port", port);
    Dbg("port: %d, baudrate: %d", port, baudRate);
	result = m_hDevHelper->DevOpen(port, baudRate);
    if (result != Error_Succeed) {
		SetErrPackage(m_errPkg, "OnInit::DevOpen", m_csDevNo, result, MEC_DEVAPI_UPS_DevOpen);
		AlarmDEC(m_errPkg);
		return result;
    }

    Dbg("open ups succeed.");
    m_bDevOpen = true;
	ZeroMemory(m_devCatInfo.szModel, sizeof(m_devCatInfo.szModel));
	ZeroMemory(m_devCatInfo.szType, sizeof(m_devCatInfo.szType));
	ZeroMemory(m_devCatInfo.szVendor, sizeof(m_devCatInfo.szVendor));
	result = m_hDevHelper->GetDevCategory(m_devCatInfo);
	if (result == Error_Succeed)
	{
		Dbg("szVendor:%s", m_devCatInfo.szVendor);
		Dbg("szType:%s", m_devCatInfo.szType);
		Dbg("szModel:%s", m_devCatInfo.szModel);
		m_adapterInfo.devCatInfo = m_devCatInfo;
	}
	else {
		SetErrPackage(m_errPkg, "OnInit::GetDevCategory", m_csDevNo, result, MEC_DEVAPI_UPS_GetDevCategory);
		AlarmDEC(m_errPkg);
	}
	return Error_Succeed;
}
ErrorCodeEnum CUpsFSM::OnExit()
{
	ErrorCodeEnum eErr = Error_Succeed;
	m_hDevHelper.TearDown();
	m_bDevOpen = false;
	return eErr;
}

void CUpsFSM::s0_on_entry()
{
	UpsStatusEnum eUpsState;
	ErrorCodeEnum eErrCode = m_hDevHelper->GetDevStatus(eUpsState);
	if (eErrCode != Error_Succeed) {
		LOG_UPS_ERROR_MSG_MACRO(eErrCode, GetDevStatus);
	} else {
		Dbg("UpsState: %d", eUpsState);
	}
	m_testResult = Error_Succeed;

	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogWarnInfoAboutTerm(this, m_adapterInfo);
	}
}
void CUpsFSM::s0_on_exit()
{

}
unsigned int CUpsFSM::s0_on_event(FSMEvent* e)
{
	switch(e->iEvt)
	{
	case USER_EVT_SHUTDOWN:
		{
			e->SetHandled();
			ShutDownTask* task = new ShutDownTask(this);
			ShutDownEvent* sde = dynamic_cast<ShutDownEvent*>(e);
			task->ctx = sde->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 0;
		}
		break;
	case USER_EVT_GETSTATUS:
		{
			e->SetHandled();
			UpsStatusEnum eUpsState;
			ErrorCodeEnum eErrState = m_hDevHelper->GetDevStatus(eUpsState);
			Dbg("%s,%d",SpStrError(eErrState), eUpsState);
			GetStatusEvent* pGse = dynamic_cast<GetStatusEvent*>(e);
			pGse->ctx->Ans.Status = eUpsState;
			Dbg("status: %d",pGse->ctx->Ans.Status);
			pGse->ctx->Answer(eErrState);
		}
		break;
	default:
		return 1;
	}
	return 0;
}

void CUpsFSM::s1_on_entry()
{
}
void CUpsFSM::s1_on_exit()
{

}
unsigned int CUpsFSM::s1_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	switch(e->iEvt)
	{
	case USER_EVT_SHUTDOWN_FINISHED:
		{
			e->SetHandled();
			return e->param1;
		}
	default:
		return 1;
	}
}

void CUpsFSM::s2_on_entry()
{
	CheckTask *pTask = new CheckTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	m_testResult = Error_InvalidState;
}
void CUpsFSM::s2_on_exit()
{
}
unsigned int CUpsFSM::s2_on_event(FSMEvent* pEvt)
{
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_CHECK_FINISHED:
		ret = pEvt->param1;
		break;
	default:
		break;
	}
	return ret;
}

int CUpsFSM::ShutDown(SpReqAnsContext<UpsService_Shutdown_Req,UpsService_Shutdown_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	UpsStatusEnum eUpsStatus;
    Dbg("shutdown time: %d, uptime: %d", ctx->Req.ShutdownTime, ctx->Req.UpTime);
	ErrorCodeEnum err = m_hDevHelper->GetDevStatus(eUpsStatus);
	Dbg("(%s)status:[%d],%d,%d",SpStrError(err), eUpsStatus, ctx->Req.ShutdownTime, ctx->Req.UpTime);
    if (ctx->Req.ShutdownTime < 0 || ctx->Req.UpTime < 0) {
        Dbg("error param");
        ctx->Answer(Error_Param);
        return 2; //do not jump
    }
	err = m_hDevHelper->Shutdown(ctx->Req.ShutdownTime,ctx->Req.UpTime);
	if (err == Error_Succeed)
	{
		Dbg("shutdown...");
		ctx->Answer(Error_Succeed);
		return 0;
	}
	else
	{
		LOG_UPS_ERROR_MSG_MACRO(err, Shutdown);
		ctx->Answer(Error_Unexpect);
		return 1;
	}
}
int CUpsFSM::CheckStatus()
{
	int i = 0;
	while(1)
	{
		if (m_hDevHelper)
		{
			UpsStatusEnum eUpsStatus;
			ErrorCodeEnum eErr;
			eErr = m_hDevHelper->GetDevStatus(eUpsStatus);
			if (eErr == Error_Succeed)
			{
				Dbg("CheckStatus %d",eUpsStatus);
				if (eUpsStatus == UPS_STATUS_NORMAL || eUpsStatus == UPS_STATUS_NO_ELECTOR)
					return 0;
			}
		}
		Sleep(10000);
		i++;
		if (i > 30)
		{
			Dbg("have try 5 minutes.");
			i = 0;
		}
	}
	return 1;
}
void CUpsFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(m_testResult);
}