server1/Server/ThreadManager/ThreadAlarmManager.cpp

#include "ThreadAlarmManager.h"


#include "GlobalInfo.h"
#include "spdlog.h"
#include <mutex>
#include <thread>

ThreadAlarmManager::~ThreadAlarmManager()
{

}



/* 线程工作函数 */
void ThreadAlarmManager::thread_task()
{
    /* 初始化信息 */
    if(!initData())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "报警信息处理线程初始化数据失败");
        return;
    }

    /* 设置标志位 */
    m_isRunning = true;
    m_isStop = false;
    m_threadState = EThreadState::State_Running;

    SPDLOG_LOGGER_INFO(m_logger, "⚡ 报警信息处理线程开始运行");

    /* 运行线程功能 */
    task();

    /* 清理数据 */
    clearData();
    m_threadState = EThreadState::State_Stopped;
    m_isStop = true;
    SPDLOG_LOGGER_WARN(m_logger, "⚡ 报警信息处理线程结束运行");
}

/* 停止线程 */
void ThreadAlarmManager::thread_stop()
{
    m_isRunning = false; // 设置线程停止标志位
}

void ThreadAlarmManager::thread_stopBlock()
{
    thread_stop();
    while(m_threadState != EThreadState::State_Stopped) // 等待线程停止
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}


/* 添加报警内容 */
void ThreadAlarmManager::addAlarmInfo(const AlarmInfo_t& alarmInfo)
{
    std::lock_guard<std::mutex> lock(m_mutexListAlarm);
    m_listAlarm.push_back(alarmInfo);
}

void ThreadAlarmManager::addAlarmInfo(const std::list<AlarmInfo_t>& listAlarm)
{
    std::lock_guard<std::mutex> lock(m_mutexListAlarm);
    m_listAlarm.insert(m_listAlarm.end(), listAlarm.begin(), listAlarm.end());
}


/* 添加一致性报警信息，键为主通道信息，值为次通道信息 */
void ThreadAlarmManager::addAlarmInfo(const AlarmInfo_t& mainAlarm, const AlarmInfo_t& subAlarm)
{
    std::lock_guard<std::mutex> lock(m_mutexListAlarmConsistency);
    m_listAlarmConsistency.push_back(std::make_pair(mainAlarm, subAlarm));
}


/* 线程工作函数 */
void ThreadAlarmManager::task()
{
    while(m_isRunning.load())
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 每100毫秒执行一次

        {
            /* 普通的报警数据写入数据库 */
            std::lock_guard<std::mutex> lock(m_mutexListAlarm);
            if(m_listAlarm.empty())
            {
                continue; // 如果没有报警信息，继续循环
            }
            if(!m_fromWebAPI.insertAlarmInfo(m_listAlarm))
            {
                SPDLOG_LOGGER_ERROR(m_logger, "写入报警信息失败");
            }
            /* 清空报警列表 */
            m_listAlarm.clear();
        }

        {
            /* 写入一致性报警信息 */
            std::lock_guard<std::mutex> lock(m_mutexListAlarmConsistency);
            if(m_listAlarmConsistency.empty())
            {
                continue; // 如果没有一致性报警信息，继续循环
            }
            for(const auto& alarmPair : m_listAlarmConsistency)
            {
                if(!m_fromWebAPI.insertConsistencyAlarmInfo(alarmPair.first, alarmPair.second))
                {
                    SPDLOG_LOGGER_ERROR(m_logger, "写入一致性报警信息失败");
                }
            }
            /* 清空报警信息 */
            m_listAlarmConsistency.clear();
        }

    }
}

/* 初始化数据 */
bool ThreadAlarmManager::initData()
{
    if(m_logger == nullptr)
    {
        m_logger = spdlog::get("Alarm");
        if(m_logger == nullptr)
        {
            fmt::print("Alarm is nullptr");
            return false; // 日志记录器获取失败
        }
    }

    /* 登陆WebAPI */
    if(!m_fromWebAPI.initWebApi(GInfo.webAPIUrl(), GInfo.webAPIID(), GInfo.webApiAppType()))
    {
        SPDLOG_LOGGER_ERROR(m_logger, "报警信息处理线程登录WebAPI失败");
        return false;
    }
    SPDLOG_LOGGER_INFO(m_logger, "报警信息处理线程登录WebAPI成功");


    return true;
}

/* 清理数据 */
void ThreadAlarmManager::clearData()
{

}