Middlewares-Linux/CallOut/EslMgr.cpp

#include "EslMgr.h"
#include "EslGateway.h"
#include <sstream>
#include "Log.h"

EslMgr EslMgr::instance;

bool EslMgr::AddEslGateway(const std::string & strIP, const std::int16_t & nPort, const std::string & strPwd, const std::int32_t & nTrunkCount)
{
	std::unique_lock<std::shared_timed_mutex>lock(mut);
	auto it = std::find_if(m_lstEslGateway.begin(), m_lstEslGateway.end(),
		[=](const std::shared_ptr<EslGateway>&esl) {
		return esl->IsEslGateway(strIP, nPort, strPwd);
	});
	if (it == m_lstEslGateway.end()) { // 不存在，添加
		auto pEsl = std::make_shared<EslGateway>(nTrunkCount);
		bool ret = pEsl->init(strIP, nPort, strPwd);
		if (ret) {
			m_lstEslGateway.emplace_back(pEsl);
			return true;
		}
		
	}
	return false;
}

bool EslMgr::DelEslGateway(const std::string & strIP, const std::int16_t & nPort, const std::string & strPwd)
{
	std::unique_lock<std::shared_timed_mutex>lock(mut);
	for (auto it = m_lstEslGateway.begin(); it != m_lstEslGateway.end(); ++it) {
		if ((*it)->IsEslGateway(strIP, nPort, strPwd)) {
			m_lstEslGateway.erase(it);
			return true;
		}
	}
	return false;
}

std::int32_t EslMgr::GetUsableTotal()
{
	std::int32_t nUsable = 0;
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	for (const auto esl : m_lstEslGateway) {
		nUsable += esl->GetUsableCount();
	}
	return nUsable;
}

void EslMgr::ExecTask(const TASK_TYPE&emType, const std::list<std::shared_ptr<TaskData>>& lstTaskData)
{
	switch (emType)
	{
	case TASK_TYPE_LOOP:
		strategyLoop(lstTaskData);
		break;
	case TASK_TYPE_CFG_PRIORITY:
		strategyCfgPriority(lstTaskData);
		break;
	default:
		strategyLoop(lstTaskData);
		break;
	}
}

void EslMgr::ExecTask(const TASK_TYPE & emType, const std::shared_ptr<TaskData>& pTaskData)
{
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	for (auto esl : m_lstEslGateway) {
		if (esl->IsConn()) {
			execTaskCall(esl, pTaskData);
			break;
		}
	}
}

void EslMgr::ExecTask(const std::list<std::shared_ptr<TaskData>>& lstTaskData)
{
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	auto it = m_lstEslGateway.begin();
	for (auto task : lstTaskData) {
		if (it == m_lstEslGateway.end()) {
			break;
		}
		else {
			const auto esl = *it;
			if (esl->GetUsableCount() > 0 && esl->IsConn())
				execTaskCall(esl, task);
			++it;
		}
	}
}

bool EslMgr::isExists(const std::string & strIP, const std::int16_t & nPort, const std::string & strPwd)
{
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	for (const auto esl : m_lstEslGateway) {
		if (esl->IsEslGateway(strIP, nPort, strPwd))
			return true;
	}
	return false;
}

void EslMgr::strategyLoop(const std::list<std::shared_ptr<TaskData>>& lstTaskData)
{
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	auto it = m_lstEslGateway.begin();
	for (auto task : lstTaskData) {
		if (it == m_lstEslGateway.end()) {
			break;
		}
		else {
			const auto esl = *it;
			if (esl->GetUsableCount() > 0 && esl->IsConn())
				execTaskCall(esl, task);
			++it;
		}
	}
}

void EslMgr::strategyCfgPriority(const std::list<std::shared_ptr<TaskData>>& lstTaskData)
{
	auto lstData = lstTaskData;
	std::shared_lock<std::shared_timed_mutex>lock(mut);
	for (auto it = m_lstEslGateway.begin(); it != m_lstEslGateway.end(); it++) {
		const auto esl = *it;
		auto n = esl->GetUsableCount();
		for (auto i = 0; i < n && esl->IsConn(); ++i) {
			auto task = lstData.front();
			execTaskCall(esl, task);
			lstData.pop_front();
		}
	}
}

bool EslMgr::execTaskCall(const std::shared_ptr<EslGateway>& pEsl, const std::shared_ptr<TaskData>& pTask)
{
	if (pEsl) {
		std::stringstream ss;
		ss << "bgapi lua CallOut.lua ";
		ss << pTask->llID <<" " <<pTask->lltaskID;
		ss << " ";
		ss << pTask->strFix << pTask->strPhone;
		ss << " "<<pTask->llUID;
		ss << " " << pTask->strTaskItemIDS;
		LOG_DEBUG("lua执行 %s",ss.str().c_str());
		return pEsl->sendCmd(ss.str());
	}
	return false;
}