myvtm/spbase/SpModule.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpEntity.h"
#include "SpEntityPrivilege.h"
#include "SpModule.h"

#include "sp_dbg_export.h"
#include "sp_log.h"
#include "sp_def.h"
#include "sp_env.h"

#include "strutil.h"
#ifdef _WIN32
#include "sp_checkEntity.h"
#endif //_WIN32

#include <winpr/thread.h>

SpModule::SpModule( sp_mod_t *mod, sp_cfg_shell_module_t *cfg_mod ) 
	: m_arrEntity(NULL)
	, m_iom(NULL)
	, m_mod(mod), 
m_anonymous_log(NULL), m_stub(NULL), m_cfg_mod(cfg_mod)
{
	m_dwEntityTls = TlsAlloc();
}

SpModule::~SpModule()
{
	TlsFree(m_dwEntityTls);
}

void SpModule::SetThreadEntity(SpEntity* pEntity)
{
	TlsSetValue(m_dwEntityTls, pEntity);
}

SpEntity* SpModule::GetThreadEntity() 
{
	return (SpEntity*)TlsGetValue(m_dwEntityTls);
}


void SpModule::LogMessage( const LogTypeEnum LogType, const SeverityLevelEnum Level, DWORD dwSysErrorCode, DWORD dwUserErrorCode, const char *pMessage )
{
#ifdef _WIN32
	SpEntity* pEntity = (SpEntity*)(getEntityResource()->m_Entity);
#else
	SpEntity* pEntity = GetThreadEntity();
#endif //_WIN32

	if (!pEntity) {
		if (m_arrEntity->nelts == 1)
			pEntity = ARRAY_IDX(m_arrEntity, 0, SpEntity*);
	}

	if (pEntity) {
		pEntity->LogMessage(LogType, Level, dwSysErrorCode, dwUserErrorCode, pMessage);
	} else {
		sp_dbg_warn("use anonymous name to log!");
		sp_log_client_log(m_anonymous_log, LogType, Level, (int)dwSysErrorCode, (int)dwUserErrorCode, 0, 0, pMessage);
	}
}

ErrorCodeEnum SpModule::Init( const char *url )
{
	//sp_env_t *env = sp_get_env();
	//void *shm_addr = env->shm_addr;
	int rc;

	m_arrEntity = array_make(0, sizeof(SpEntity*));

	rc = sp_iom_create(url, m_mod->cfg->idx, &m_iom);
	if (rc != 0)
		return Error_Param;

	rc = sp_log_client_create(NULL, m_iom, &m_anonymous_log);
	if (rc != 0)
		return Error_Unexpect;

	sp_mod_stub_cb cb;
	cb.on_module_init = &SpModule::__on_module_init;
	cb.on_module_term = &SpModule::__on_module_term;
	cb.user_data = this;

	rc = sp_mod_stub_create(&cb, m_iom, &m_stub);
	if (rc != 0)
		return Error_Unexpect;

	return Error_Succeed;
}

VOID SpModule::Term()
{
	
	sp_mod_stub_destroy(m_stub);

	RemoveEntityBase(NULL); // remove all

	if (m_anonymous_log) {
		Dbg("destroy log client.");
		sp_log_client_destroy(m_anonymous_log);
		m_anonymous_log = NULL;
	}

	if (m_iom) {
		Dbg("destroy iom.");
		sp_iom_destroy(m_iom);
		m_iom = NULL;
	}

	array_free(m_arrEntity);
}

ErrorCodeEnum SpModule::Run()
{
	sp_iom_run(m_iom);

	return Error_Succeed;
}

int SpModule::on_module_init()
{
#ifdef _WIN32
	EntryRoutine curPfMain = (EntryRoutine)getEntityResource()->m_pfMain;
	if (NULL != curPfMain)
		return curPfMain();
#else
	if (SpModule::s_pfMain) {
		return SpModule::s_pfMain();
	}
#endif //_WIN32
	return Error_NotInit; // dont allow use null routine
}

int SpModule::on_module_term()
{
	Dbg("on_module_term");
#ifdef _WIN32
	EntryRoutine curPfExit = (EntryRoutine)getEntityResource()->m_pfExit;
#endif //_WIN32
	if (SpModule::s_pfExit)
		return SpModule::s_pfExit();
#ifdef _WIN32
	if (NULL != curPfExit)
		return curPfExit();
#endif //_WIN32
	return Error_Succeed; // allow use null routine
}

int SpModule::__on_module_init(sp_mod_stub_t *stub, void *user_data)
{
	SpModule *pThis = (SpModule *)user_data;
	return pThis->on_module_init();
}

int SpModule::__on_module_term(sp_mod_stub_t *stub, void *user_data)
{
	SpModule *pThis = (SpModule *)user_data;
	return pThis->on_module_term();
}

ErrorCodeEnum SpModule::AddEntityBase(CEntityBase *pEntity)
{
	sp_env_t *env = sp_get_env();
	const char *lpEntityName = pEntity->GetEntityName();
	SpEntity *pSpEntity = FindEntity(lpEntityName);
	if (pSpEntity) {
		return Error_AlreadyExist;
	}
	sp_entity_t *ent = sp_mod_mgr_find_entity_by_name(env->mod_mgr, lpEntityName);
	if (!ent || ent->mod->cfg->idx != m_mod->cfg->idx) {
		sp_dbg_warn("entity %s does not exist in current module!", lpEntityName);
		return Error_Bug;
	}
	//MessageBoxA(0,0,0,0);
	sp_cfg_shell_entity_t *cfg_ent = sp_cfg_get_entity_by_idx(env->cfg, ent->cfg->idx);
	if (cfg_ent->privilege) {
		pSpEntity = new SpEntityPrivilege(this, ent, cfg_ent, pEntity);
	} else {
		pSpEntity = new SpEntity(this, ent, cfg_ent, pEntity);
	}
	ErrorCodeEnum Error = pSpEntity->Init();
	if (Error == Error_Succeed) {
		ARRAY_PUSH(m_arrEntity, SpEntity*) = pSpEntity;
		pEntity->m_pEntityFunction = pSpEntity;
	} else {
		delete pSpEntity;
		pSpEntity = NULL;
	}
	return Error;
}

ErrorCodeEnum SpModule::RemoveEntityBase(CEntityBase *pEntity)
{
	ErrorCodeEnum Error = Error_Unexpect;
	const char *lpEntityName = pEntity ? pEntity->GetEntityName() : NULL;
	for (int i = 0; i < m_arrEntity->nelts; ++i) {
		SpEntity *pSpEntity = ARRAY_IDX(m_arrEntity, i, SpEntity*);
		if (lpEntityName == NULL || _stricmp(lpEntityName, pSpEntity->get_ent()->cfg->name) == 0) {
			if (i != m_arrEntity->nelts-1) {
				ARRAY_IDX(m_arrEntity,i,SpEntity*) = ARRAY_IDX(m_arrEntity,m_arrEntity->nelts-1,SpEntity*);
			}
			array_pop(m_arrEntity);
			pSpEntity->Term();
			delete pSpEntity;
			pSpEntity = NULL;
			Error = Error_Succeed;
			break;
		}
	}
	return Error;
}

ErrorCodeEnum SpModule::GetEntityBase(const char *pszEntityName,CSmartPointer<CEntityBase> &pEntity)
{
	SpEntity *pSpEntity = FindEntity(pszEntityName);
	if (pSpEntity) {
		pEntity = CSmartPointer<CEntityBase>(pSpEntity->GetEntityBase());
		return Error_Succeed;
	}
	return Error_NotExist;
}

int SpModule::GetEntityCount()
{
	return m_arrEntity->nelts;
}

SpEntity *SpModule::FindEntity(const char *lpName)
{
	if (lpName) {
		for (int i = 0; i < m_arrEntity->nelts; ++i) {
			SpEntity *t = ARRAY_IDX(m_arrEntity, i, SpEntity *);
			if (_stricmp(t->get_ent()->cfg->name, lpName) == 0)
				return t;
		}
	}
	return NULL;
}

EntryRoutine SpModule::s_pfExit = NULL;

EntryRoutine SpModule::s_pfMain = NULL;