SCADATrainSys/CCGDServer/ElectrictiyServerQt/TaskMNG.cpp

#include "TaskMNG.h"

#include "platform.h"
#include "NetMessageDefine.h"
//#include <dlfcn.h>
#include <YD_Public_OCC.h>
#ifdef Q_OS_WIN
#pragma execution_character_set("utf-8")
#endif
TaskMNG* TaskMNG::g_GlobalSingle = NULL;
std::mutex TaskMNG::m_Mutex;



#include "ElectricityVOC.h"
#include <QLibrary>
#include <QCoreApplication>
//单例初始化
typedef CBaseDispatch* (*Create_Sub_Dispatch)();

TaskMNG* TaskMNG::instance()
{
    if (g_GlobalSingle == NULL)
    {
        std::unique_lock<std::mutex> lock(m_Mutex);
        if (g_GlobalSingle == NULL)
        {
            g_GlobalSingle = new (std::nothrow) TaskMNG();
        }
    }
    return g_GlobalSingle;

}

void TaskMNG::destroyInstance()
{
    std::unique_lock<std::mutex> lock(m_Mutex);
    //NetDll_StopThread();
    if (g_GlobalSingle)
    {
        delete g_GlobalSingle;
        g_GlobalSingle = NULL;
    }
}


TaskMNG::TaskMNG()
{
	nTaskStatus = Status_Null;
}

TaskMNG::~TaskMNG()
{

}


void TaskMNG::InitDB(string strIP, int nType, string strDBname, string strUser, string strPwd)
{
	//m_pdb = new YD_DBOperator();
	int nPort = 0;
	if (nType==1)
	{
		nPort = 8527;
	}
	else
	{
		nPort = 1433;
	}
	m_strSeverIP = strIP;
	m_nDBType = nType;
	m_strDBName = strDBname;
	m_strUserID = strUser;
	m_strPassWord = strPwd;
	//m_pdb->SetDBType(nType);
	//m_pdb->ConnectDB(strIP,strUser,strPwd,strDBname, nPort);

}

bool TaskMNG::CreateDispatchTask(int courseid, int systype, int trainid, int runlineid, int parm1, int parm2, InitCourInfo* curseinfo)
{

	SVRREPLYMSG netret;
	memset(&netret, 0, sizeof(netret));
	netret.sysType = systype;
	string logstr;

	bool ret = true;
	netret.status = OCC_NETMESSAGE_TRIAN_CREATE_FAIL;

	string key = Make2IntKey_2(systype, trainid);
	//EnterCriticalSection(&m_pDispatchTasksMappretect);
	DISTASKMAP::iterator iter = m_DispatchTasksMap.find(key);

	if (iter == m_DispatchTasksMap.end())
	{
		//std::string Str_Dll = 
#ifdef Q_OS_WIN
		QString StdPath = QCoreApplication::applicationDirPath() + "/Elc.dll";
#else
		QString StdPath = QCoreApplication::applicationDirPath() + "/libElc.so";
#endif
		std::string Str_Dll = StdPath.toStdString();
        QLibrary myLib;
        myLib.setFileName(StdPath);
		
        // 对于Windows系统
        // QLibrary myLib("/path/to/your/so/libmylib.so"); // 对于Linux系统

		if (!myLib.load())
		{
			// 获取函数地址
			return false;
		}
		Create_Sub_Dispatch pCreateDispatchTaskMg = (Create_Sub_Dispatch)myLib.resolve("Create_Sub_Dispatch");
		CBaseDispatch* pdispatchsys = pCreateDispatchTaskMg();
		if (pdispatchsys == NULL)
		{
			logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "失败\n";
			AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_ERROR);
			ret = false;
			netret.status = OCC_NETMESSAGE_TRIAN_CREATE_FAIL;
			nTaskStatus = Status_Error;
		}
		else
		{
			ElectricityVOC* pElect = (ElectricityVOC*)pdispatchsys;
			//RecTrianPosition(systype, trainid, m_NetServerID);
/*
			DATECONFIGMAP::iterator iter = m_DataBaseConfigMap.find(systype);
			if (iter == m_DataBaseConfigMap.end())
			{
				logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "没有找到数据库配置项\n";
				AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_NORMAL);
				ret = false;
				netret.status = OCC_NETMESSAGE_TRIAN_CREATE_FAIL;
			}
			else*/ 
			m_pdb = new YD_DBOperator();
			m_pdb->SetDBType(m_nDBType);
			pElect->setDBP(m_pdb,&pLogCtrl);
			curseinfo = new InitCourInfo();
			if (!pdispatchsys->OpenDB(m_strSeverIP, m_strDBName, m_strUserID, m_strPassWord, courseid, runlineid, parm1, parm2, m_nDBType, curseinfo))
			{
				pdispatchsys->Exit();
				delete pdispatchsys;
				pdispatchsys = NULL;
				logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "打开数据库任务失败\n";
				AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_ERROR);
				ret = false;
				netret.status = OCC_NETMESSAGE_TRIAN_CREATE_FAIL;
				nTaskStatus = Status_Error;
			}
			else if (!pdispatchsys->OpenWork(trainid, systype, &m_pSendList, &m_pSendGroupList, &m_pSendRealList))
			{
				pdispatchsys->Exit();
				delete pdispatchsys;
				pdispatchsys = NULL;
				logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "失败\n";
				AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_NORMAL);
				ret = false;
				netret.status = OCC_NETMESSAGE_TRIAN_CREATE_FAIL;
				nTaskStatus = Status_Error;
			}
			else
			{
				m_DispatchTasksMap.insert(make_pair(key, pdispatchsys));
				logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "成功\n";
				AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_NORMAL);
				netret.status = OCC_NETMESSAGE_TRIAN_CREATE_SUCCESS;
				nTaskStatus = Status_Init;
			}
		}
	}
	else
	{
		logstr = "调度服务器创建:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "失败! 该训练已经存在\n";
		AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_ERROR);
		netret.status = OCC_NETMESSAGE_TRIAN_CREATE_EXIST;
		nTaskStatus = Status_Error;
	}

	//strncpy(netret.ReplyText, logstr.c_str(), sizeof(ALARM_LEN));

// 	if (curseinfo->coursetype == OCCCOMMAND::eTrainIni)	//其他流程单独发送
// 	{
// 		NetComand_Send(&netret, OCC_SYS_SERVER_TH, OCCCOMMAND::eSvrReplyMsg, trainid);//创建课程
// 	}
	return ret;
}

bool TaskMNG::DeleteDispatchTask(int courseid, int systype, int trainid)
{
	bool returnflag = false;
	SVRREPLYMSG netret;
	netret.sysType = systype;
	string logstr;
	bool ret = true;
	netret.status = OCC_NETMESSAGE_TRIAN_DELETE_SUCCESS;
	string key = Make2IntKey_2(systype, trainid);
	/*DISTASKMAP::iterator iter = m_DispatchTasksMap.find(key);
	if (iter!=m_DispatchTasksMap.end())*/

	bool findflag = false;
	//std::unique_lock<std::recursive_mutex> g1(m_pDispatchTasksMappretect);
	//EnterCriticalSection(&m_pDispatchTasksMappretect);
	for (DISTASKMAP::iterator iter = m_DispatchTasksMap.begin()
		; iter != m_DispatchTasksMap.end()
		; //iter ++
		)
	{
		CBaseDispatch* pdispatchsys = iter->second;
		if (pdispatchsys == NULL)
		{
			m_DispatchTasksMap.erase(iter);
			//LeaveCriticalSection(&m_pDispatchTasksMappretect);
			nTaskStatus = Status_Null;
			return false;
		}
		else
		{
			if (pdispatchsys->m_subsystype != systype)
			{
				iter++;
				continue;
			}
			else
			{
				courseid = pdispatchsys->m_courseid;
				systype = pdispatchsys->m_subsystype;
				trainid = pdispatchsys->m_trianid;
			}
		}
		findflag = true;
		if (pdispatchsys->StopTask(netret.parm))
		{
			returnflag = true;
			pdispatchsys->Exit();
			//DeleteReceiveGroupMsg(trainid, systype);
			//Sleep(1000);
			delete pdispatchsys;
			pdispatchsys = NULL;
			netret.status = OCC_NETMESSAGE_TRIAN_DELETE_SUCCESS;
			logstr = "调度服务器删除:" + GetSysTypeStr(systype) + "训练号:" + std::to_string(trainid) + "成功\n";
			AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_NORMAL);
			//DISTASKMAP::iterator tmpiter = iter;
			m_DispatchTasksMap.erase(iter);
			nTaskStatus = Status_Null;
			iter = m_DispatchTasksMap.begin();
		}
		else
			netret.status = OCC_NETMESSAGE_TRIAN_DELETE_FAIL;

	}
	if (!findflag)
	{
		netret.status = OCC_NETMESSAGE_TRIAN_DELETE_CANNOETFIND;
	}
	strncpy(netret.ReplyText, logstr.c_str(), sizeof(ALARM_LEN));
	//NetComand_Send(&netret, OCC_SYS_SERVER_TH, OCCCOMMAND::eSvrReplyMsg, trainid);//创建课程

	nTaskStatus = Status_Null;
	return returnflag;
}

bool TaskMNG::StopDispatchTask(int courseid, int systype, int trainid)
{
    SVRREPLYMSG netret;
    netret.sysType = systype;

    bool ret = true;
    string key = Make2IntKey_2(systype, trainid);

    //EnterCriticalSection(&m_pDispatchTasksMappretect);
    DISTASKMAP::iterator iter = m_DispatchTasksMap.find(key);
    if (iter != m_DispatchTasksMap.end())
    {
        CBaseDispatch* pdispatchsys = iter->second;
        if (pdispatchsys == NULL)
        {
            m_DispatchTasksMap.erase(iter);
            //LeaveCriticalSection(&m_pDispatchTasksMappretect);
            return false;
        }
        if (pdispatchsys->StopTask(netret.parm))
        {
            netret.status = OCC_NETMESSAGE_TRIAN_STOP_SUCCESS;
        }
		else
		{
			netret.status = OCC_NETMESSAGE_TRIAN_STOP_FAIL;
		}
    }
    else
    {
        netret.status = OCC_NETMESSAGE_TRIAN_STOP_CANNOETFIND;
    }
	nTaskStatus = TaskStatus::Status_Stop;
	return false;
}

bool TaskMNG::PauseDispatchTask(int courseid, int systype, int trainid)
{
	return false;
}

bool TaskMNG::ResumeDispatchTask(int courseid, int systype, int trainid)
{
	return false;
}

bool TaskMNG::RunDispatchTask(int courseid, int systype, int trainid)
{
    SVRREPLYMSG netret;
    netret.sysType = systype;

    bool ret = true;
    netret.status = OCC_NETMESSAGE_TRIAN_RUN_SUCCESS;
    string key = Make2IntKey_2(systype, trainid);
    //std::unique_lock<std::recursive_mutex> g1(m_pDispatchTasksMappretect);
    //EnterCriticalSection(&m_pDispatchTasksMappretect);
    DISTASKMAP::iterator iter = m_DispatchTasksMap.find(key);
    if (iter != m_DispatchTasksMap.end())
    {
        CBaseDispatch* pdispatchsys = iter->second;

        if (pdispatchsys == NULL)
        {
            m_DispatchTasksMap.erase(iter);
            //LeaveCriticalSection(&m_pDispatchTasksMappretect);
			nTaskStatus = Status_Null;
            return false;
        }

        if (pdispatchsys->StartTask(netret.parm))
        {
            //pdispatchsys->m_begintime = time(NULL);
            //tm* t = localtime(&pdispatchsys->m_begintime);
            //pdispatchsys->m_begintime = CTime::GetCurrentTime().GetTime();
            netret.status = OCC_NETMESSAGE_TRIAN_RUN_SUCCESS;
        }
        else
            netret.status = OCC_NETMESSAGE_TRIAN_RUN_FAIL;

    }
    else
    {
        netret.status = OCC_NETMESSAGE_TRIAN_RUN_CANNOETFIND;
    }
    //LeaveCriticalSection(&m_pDispatchTasksMappretect);
	nTaskStatus = Status_Run;
    //NetComand_Send(&netret, OCC_SYS_SERVER_TH, OCCCOMMAND::eSvrReplyMsg, trainid);//创建课程
    return true;
}

//内部互相之间数据传输
bool TaskMNG::NetComand_Receive(OCCCOMMAND& command)
{

    if (command.DesSysType == OCC_SYS_SERVER_SVR)
    {
		return false;
        //return NetComandToServer(command);
    }
    else
    {
        string key = Make2IntKey_2(command.DesSysType, command.TrainningID);
//         if (command.ScrNetID == m_nDebugClientSysID)
//         {
//             key = Make2IntKey(command.DesSysType, m_nTrainID);
//             command.TrainningID = m_nTrainID;
//         }
        //std::unique_lock<std::recursive_mutex> g1(m_pDispatchTasksMappretect);
        //EnterCriticalSection(&m_pDispatchTasksMappretect);
        DISTASKMAP::iterator iter = m_DispatchTasksMap.find(key);
        if (iter != m_DispatchTasksMap.end())
        {
            CBaseDispatch* pdispatchsys = iter->second;
            if (pdispatchsys == NULL)
            {
                m_DispatchTasksMap.erase(iter);
                //LeaveCriticalSection(&m_pDispatchTasksMappretect);
                return false;
            }
            pdispatchsys->ReceiveMsg(command);
            //LeaveCriticalSection(&m_pDispatchTasksMappretect);
            return true;
        }
        //LeaveCriticalSection(&m_pDispatchTasksMappretect);
    }

    string logstr;
    logstr = "未知网络系统消息:DesSysType = " + GetSysTypeStr(command.DesSysType) + "训练号:" + std::to_string(command.TrainningID) + "\n";
    //logstr.Format("未知网络系统消息:DesSysType=%d,TrianID=%d", command.DesSysType, command.TrainningID);
    //AddLogItem(GetCurTime_ms(), logstr, LOG_LEVEL_NORMAL);

    return false;
}


void TaskMNG::NetComand_Send(LPBASENETPACKET pnetmsg, int dessystype, OCCCOMMAND::CmdType cmdtype, int trianid, int nDesID /*= -1*/)
{
    OCCCOMMAND NetOrder;
    NetOrder.ScrSysType = OCC_SYS_SERVER_SVR;
    NetOrder.setPacketValue(pnetmsg, cmdtype);
    NetOrder.TrainningID = trianid;
    NetOrder.DesSysType = dessystype;
    NetOrder.DesNetID = nDesID;
    m_pSendList.push(NetOrder);
}

CBaseDispatch* TaskMNG::CreateNewTaskType(int systype)
{
	CBaseDispatch* pDispatchSys = NULL;
    //创建子模块
	auto iters = m_PluginMap.find(systype);
	if (iters==m_PluginMap.end())
	{
		return pDispatchSys;
	}
	sPlugin* pPlugin = &iters->second;//GetPlugin_ByModuleID(systype);
    if (NULL != pPlugin && NULL != pPlugin->bInitOk)
    {
        pDispatchSys = pPlugin->nCreatePlug();
		
        //pDispatchSys->Module_Init(m_pdb, m_funAddLog, m_pLocalQT);
    }
    return pDispatchSys;
}

void TaskMNG::AddLogItem(string str1, string str2, int nLevel)
{
	m_strLog = str2;
}

std::string TaskMNG::GetCurTime_ms()
{
	return "";
}

CBaseDispatch* TaskMNG::pGetEleVOC()
{
	auto iters = m_DispatchTasksMap.begin();
	if (iters!=m_DispatchTasksMap.end())
	{
		return iters->second;
	}
	return nullptr;
}

BOOL LogCtrl::Add_Log(int nLevel, LPCSTR pszFmt, ...)
{
	return false;
}

TaskMNG::TaskStatus TaskMNG::getTaskStatus()
{
    return nTaskStatus;
}

std::string TaskMNG::getTaskText()
{
	return m_strLog;
}