HM-SPMS/platform/src/public/pub_sysinfo_api/SysInfoImp.cpp


/******************************************************************************//**
*    @file       SysInfoImp.h
*    @brief      系统拓扑信息访问库实现
*    @author     yikenan
*    @version    1.0
*    @date       
**********************************************************************************/


#include <bitset>
#include "boost/typeof/typeof.hpp"
#include "boost/format.hpp"
#include "boost/asio/ip/host_name.hpp"
#include "boost/foreach.hpp"
#include "boost/algorithm/string/predicate.hpp"

#include "pub_logger_api/logger.h"
#include "pub_utility_api/CRC32.h"
#include "common/Common.h"

#include "SysInfoImp.h"

namespace iot_public
{

CSysInfoImp::CSysInfoImp()
{

}
CSysInfoImp::~CSysInfoImp()
{

}

bool CSysInfoImp::loadData()
{
    return m_objData.loadData();
}

/**
 @brief 命令行打印输出全部的配置信息，可供测试、调试使用
 @param 
 @return
 @retval
*/
void CSysInfoImp::printAllData()
{
    m_objData.printData();
}

bool CSysInfoImp::reloadAllData()
{
    return m_objData.loadData();
}


/**
 @brief 获取所有的应用信息
 @param std::vector<SAppInfo> & vecAppInfo 返回的应用信息列表
 @return
 @retval
*/
int CSysInfoImp::getAllAppInfo(std::vector<SAppInfo> &vecAppInfo)
{
    vecAppInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapAppInfo.begin());
         it != m_objData.m_mapAppInfo.end();
         it++)
    {
        vecAppInfo.push_back(it->second);
    }

    return iotSuccess;
}

/**
 @brief 获取所有域的信息
 @param std::vector<SDomainInfo> & vecDomainInfo 返回的域信息列表
 @return
 @retval
*/
int CSysInfoImp::getAllDomainInfo(std::vector<SDomainInfo> &vecDomainInfo)
{
    vecDomainInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapDomainInfo.begin());
         it != m_objData.m_mapDomainInfo.end();
         it++)
    {
        vecDomainInfo.push_back(it->second);
    }

    return iotSuccess;
}

/**
 @brief 获取所有位置信息
 @param std::vector<SLocationInfo> & vecLocationInfo 返回的位置信息
 @return
 @retval
*/
int CSysInfoImp::getAllLocationInfo(std::vector<SLocationInfo> &vecLocationInfo)
{
    vecLocationInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapLocationInfo.begin());
         it != m_objData.m_mapLocationInfo.end();
         it++)
    {
        vecLocationInfo.push_back(it->second);
    }

    return iotSuccess;
}

/**
 @brief 获取所有的节点信息
 @param std::vector<SNodeInfo> & vecNodeInfo 返回的节点信息列表
 @return
 @retval
*/
int CSysInfoImp::getAllNodeInfo(std::vector<SNodeInfo> &vecNodeInfo)
{
    vecNodeInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapNodeInfo.begin());
         it != m_objData.m_mapNodeInfo.end();
         it++)
    {
        vecNodeInfo.push_back(it->second);
    }

    return iotSuccess;
}

/**
 @brief 获取所有的专业信息
 @param std::vector<SSubsystemInfo> & vecSubsystemInfo 返回的专业信息列表
 @return
 @retval
*/
int CSysInfoImp::getAllSubsystemInfo(std::vector<SSubsystemInfo> &vecSubsystemInfo)
{
    vecSubsystemInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapSubsystemInfo.begin());
         it != m_objData.m_mapSubsystemInfo.end();
         it++)
    {
        vecSubsystemInfo.push_back(it->second);
    }

    return iotSuccess;
}

/**
 @brief 获取指定域、应用的应用部署信息
 @param int nDomainId 域号
 @param int nAppId 应用号
 @param SAppDeploy & stAppDeploy 返回的应用部署信息
 @return
 @retval
*/
int CSysInfoImp::getAppDeployById(int nDomainId, int nAppId, SAppDeploy &stAppDeploy)
{
    //“nDomainId-nAppId”作为key
    std::string strKey = boost::str(boost::format("%d-%d") % nDomainId % nAppId);
    BOOST_AUTO(it, m_objData.m_mapAppDeploy.find(strKey));
    if (it == m_objData.m_mapAppDeploy.end())
    {
        LOGERROR("getAppDeployById(): 未找到该部署信息 nDomainId = %d, nAppId = %d",
                 nDomainId, nAppId);
        return iotFailed;
    }

    stAppDeploy = it->second;
    return iotSuccess;
}

/**
 @brief 获取指定域、应用的应用部署信息
 @param const std::string & strDomainName 域名
 @param const std::string & strAppName 专业名
 @param SAppDeploy & stAppDeploy 返回的应用部署信息
 @return
 @retval
*/
int CSysInfoImp::getAppDeployByName(const std::string &strDomainName, const std::string &strAppName, SAppDeploy &stAppDeploy)
{
    SDomainInfo stDomInfo;
    if (iotSuccess != getDomainInfoByName(strDomainName, stDomInfo))
    {
        LOGERROR("getAppDeployByName(): 未找到该域 strDomainName == %s", strDomainName.c_str());
        return iotFailed;
    }

    SAppInfo stAppInfo;
    if (iotSuccess != getAppInfoByName(strAppName, stAppInfo))
    {
        LOGERROR("getAppDeployByName(): 未找到该专业 strAppName == %s", strAppName.c_str());
        return iotFailed;
    }

    return getAppDeployById(stDomInfo.nId, stAppInfo.nId, stAppDeploy);
}

/**
 @brief 获取指定节点的应用部署信息
 @param std::string strNodeName 节点名
 @param std::vector<SAppDeploy> & vecAppDeploy 返回的应用部署信息
 @return
 @retval
*/
int CSysInfoImp::getAppDeployByNodeName(const std::string &strNodeName, std::vector<SAppDeploy> &vecAppDeploy)
{
    SNodeInfo stNodeInfo;
    if (iotSuccess != getNodeInfoByName(strNodeName, stNodeInfo))
    {
        LOGERROR("getAppDeployByNodeName(): 未找到该节点 strNodeName == %s", strNodeName.c_str());
        return iotFailed;
    }

    vecAppDeploy.clear();

    for (BOOST_AUTO(it, m_objData.m_mapAppDeploy.begin());
         it != m_objData.m_mapAppDeploy.end();
         it++)
    {
        if (it->second.nDomainId == stNodeInfo.nDomainId &&
            it->second.mapNodeToPriority.find(strNodeName) != it->second.mapNodeToPriority.end())
        {
            vecAppDeploy.push_back(it->second);
        }
    }

    return iotSuccess;
}

//virtual int getSubsystemListByNodeId(int nNodeId,std::vector<SSubsystemInfo> &vecSubsystemInfo) = 0;
/**
 @brief 通过应用ID获取应用信息
 @param int nAppId 应用ID
 @param SAppInfo & stAppInfo 返回的应用信息
 @return
 @retval
*/
int CSysInfoImp::getAppInfoById(int nAppId, SAppInfo &stAppInfo)
{
    BOOST_AUTO(it, m_objData.m_mapAppInfo.find(nAppId));
    if (it == m_objData.m_mapAppInfo.end())
    {
        LOGERROR("getAppInfoById(): 未找到该应用 nAppId == %d，请检查配置 。", nAppId);
        return iotFailed;
    }

    stAppInfo = it->second;
    return iotSuccess;
}

/**
 @brief 通过应用名获取应用信息
 @param const std::string & strAppName 应用名
 @param SAppInfo & stAppInfo 返回的应用信息
 @return
 @retval
*/
int CSysInfoImp::getAppInfoByName(const std::string &strAppName, SAppInfo &stAppInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapAppInfo.begin());
         it != m_objData.m_mapAppInfo.end();
         it++)
    {
        //不区分大小写比较
        if (boost::algorithm::iequals(strAppName, it->second.strName))
        {
            stAppInfo = it->second;
            return iotSuccess;
        }
    }

    LOGERROR("getAppInfoByName(): 未找到该应用 strAppName == %s", strAppName.c_str());
    return iotFailed;
}

/**
 @brief 获取专业所属的应用信息
 @param int nSubsystemId 专业ID
 @param SAppInfo &stAppInfo 返回的应用信息
 @return
 @retval
*/
int CSysInfoImp::getAppInfoBySubsystemId(int nSubsystemId, SAppInfo &stAppInfo)
{
    SSubsystemInfo stSubSysInfo;
    if (iotSuccess != getSubsystemInfoById(nSubsystemId, stSubSysInfo))
    {
        LOGERROR("getAppInfoBySubsystemId(): 未找到该专业 nSubsystemId == %d", nSubsystemId);
        return iotFailed;
    }
    if(stSubSysInfo.nAppId < CN_AppId_BASE)
    {
        LOGWARN("getAppInfoBySubsystemId(): nAppId == %d 不存在 ", stSubSysInfo.nAppId );
        return iotFailed;
    }

    return getAppInfoById(stSubSysInfo.nAppId, stAppInfo);
}

/**
 @brief 获取专业所属的应用信息
 @param const std::string & strSubsystemName 专业名
 @param SAppInfo &stAppInfo 返回的应用信息
 @return
 @retval
*/
int CSysInfoImp::getAppInfoBySubsystemName(const std::string &strSubsystemName, SAppInfo &stAppInfo)
{
    SSubsystemInfo stSubSysInfo;
    if (iotSuccess != getSubsystemInfoByName(strSubsystemName, stSubSysInfo))
    {
        LOGERROR("getAppInfoBySubsystemName(): 未找到该专业 strSubsystemName == %s", strSubsystemName.c_str());
        return iotFailed;
    }

    return getAppInfoById(stSubSysInfo.nAppId, stAppInfo);
}

/**
 @brief 获取中心域信息
 @param SDomainInfo & stDomainInfo 返回的中心域信息
 @return
 @retval
*/
int CSysInfoImp::getCenterDomainInfo(SDomainInfo &stDomainInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapDomainInfo.begin());
         it != m_objData.m_mapDomainInfo.end();
         it++)
    {
        if (it->second.bIsCenter)
        {
            stDomainInfo = it->second;
            return iotSuccess;
        }
    }

    LOGERROR("getCenterDomainInfo(): 未找到中心域");

    return iotFailed;
}

/**
 @brief 获取指定域的数据库配置信息
 @param int nDomainId 域号
 @param SDatabaseInfo & stFirstConnect 首链接
 @param std::vector<SDatabaseInfo> & vecLocalDBInfo 返回的本地数据库列表
 @param std::vector<SDatabaseInfo> & vecRemoteDBInfo 返回的远程数据库列表
 @return
 @retval
*/
int CSysInfoImp::getDBInfoByDomainId(int nDomainId, SDatabaseInfo &stFirstConnect,
                                     std::vector<SDatabaseInfo> &vecLocalDBInfo,
                                     std::vector<SDatabaseInfo> &vecRemoteDBInfo)
{
    BOOST_AUTO(itDbDep, m_objData.m_mapDBDeploy.find(nDomainId));
    if (m_objData.m_mapDBDeploy.end() == itDbDep)
    {
        //没有找到该域ID的配置
        LOGERROR("getDBInfoByDomainId(): 未找到该域 nDomainId == %d", nDomainId);
        return iotFailed;
    }

    //stFirstConnect
    {
        BOOST_AUTO(it1stDbInfo, m_objData.m_mapDatabaseInfo.find(itDbDep->second.strFirstConnect));
        if (m_objData.m_mapDatabaseInfo.end() != it1stDbInfo)
        {
            stFirstConnect = it1stDbInfo->second;
        }
    }

    //vecLocalDBInfo
    vecLocalDBInfo.clear();
    for (size_t i = 0; i < itDbDep->second.vecLocalNode.size(); i++)
    {
        BOOST_AUTO(itDbInfo, m_objData.m_mapDatabaseInfo.find(itDbDep->second.vecLocalNode[i]));
        if (m_objData.m_mapDatabaseInfo.end() != itDbInfo)
        {
            vecLocalDBInfo.push_back(itDbInfo->second);
        }
    }

    //vecRemoteDBInfo
    vecRemoteDBInfo.clear();
    for (size_t j = 0; j < itDbDep->second.vecRemoteDomain.size(); j++)
    {
        //通过本域的远程域ID找到远程域的DBDeploy
        const int nRmtDomID = itDbDep->second.vecRemoteDomain.at(j);
        BOOST_AUTO(itRmtDbDep, m_objData.m_mapDBDeploy.find(nRmtDomID));
        if (m_objData.m_mapDBDeploy.end() == itRmtDbDep)
        {
            continue;
        }

        //将远程域的所有数据库节点加入到vecRemoteDBInfo
        for (size_t k = 0; k < itRmtDbDep->second.vecLocalNode.size(); k++)
        {
            BOOST_AUTO(itRmtDbInfo, m_objData.m_mapDatabaseInfo.find(itRmtDbDep->second.vecLocalNode[k]));
            if (m_objData.m_mapDatabaseInfo.end() != itRmtDbInfo)
            {
                vecRemoteDBInfo.push_back(itRmtDbInfo->second);
            }
        }
    }

    return iotSuccess;
}

/**
 @brief 通过节点名获取数据库配置信息
 @param const std::string & strNodeName 节点名
 @param SDatabaseInfo & stDBInfo 返回的数据库配置信息
 @return
 @retval
*/
int CSysInfoImp::getDBInfoByNodeName(const std::string &strNodeName, SDatabaseInfo &stDBInfo)
{
    BOOST_AUTO(it, m_objData.m_mapDatabaseInfo.find(strNodeName));
    if (m_objData.m_mapDatabaseInfo.end() == it)
    {
        LOGERROR("getDBInfoByNodeName(): 未找到该数据库节点 strNodeName == %s", strNodeName.c_str());
        return iotFailed;
    }

    stDBInfo = it->second;
    return iotSuccess;
}

/**
 @brief 通过域号获取域信息
 @param int nDomainId 域号
 @param SDomainInfo & stDomainInfo 返回的域信息
 @return
 @retval
*/
int CSysInfoImp::getDomainInfoById(int nDomainId, SDomainInfo &stDomainInfo)
{
    BOOST_AUTO(it, m_objData.m_mapDomainInfo.find(nDomainId));
    if (m_objData.m_mapDomainInfo.end() == it)
    {
        LOGERROR("getDomainInfoById(): 未找到该域 nDomainId == %d", nDomainId);
        return iotFailed;
    }

    stDomainInfo = it->second;
    return iotSuccess;
}

/**
 @brief 通过域名获取域信息
 @param const std::string & strDomainName 域名
 @param SDomainInfo & stDomainInfo 返回的域信息
 @return
 @retval
*/
int CSysInfoImp::getDomainInfoByName(const std::string &strDomainName, SDomainInfo &stDomainInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapDomainInfo.begin());
         it != m_objData.m_mapDomainInfo.end();
         it++)
    {
        if (strDomainName == it->second.strName)
        {
            stDomainInfo = it->second;
            return iotSuccess;
        }
    }

    LOGERROR("getDomainInfoByName(): 未找到该域 strDomainName == %s", strDomainName.c_str());

    return iotFailed;
}

/**
 @brief 获取节点所在域信息
 @param const std::string strNodeName 节点名
 @param SDomainInfo & stDomainInfo 返回的域信息
 @return
 @retval
*/
int CSysInfoImp::getDomainInfoByNodeName(const std::string strNodeName, SDomainInfo &stDomainInfo)
{
    SNodeInfo stNodeInfo;
    if (iotSuccess != getNodeInfoByName(strNodeName, stNodeInfo))
    {
        LOGERROR("getDomainInfoByNodeName(): 未找到该节点 strNodeName == %s", strNodeName.c_str());
        return iotFailed;
    }

    return getDomainInfoById(stNodeInfo.nDomainId, stDomainInfo);
}

/**
 @brief 获取本节点的应用部署信息
 @param std::vector<SAppDeploy> & vecAppDeploy 返回的应用部署信息
 @return
 @retval
*/
int CSysInfoImp::getLocalAppDeploy(std::vector<SAppDeploy> &vecAppDeploy)
{
    const std::string strMyHostName = boost::asio::ip::host_name();
    return getAppDeployByNodeName(strMyHostName, vecAppDeploy);
}

/**
 @brief 获取本域的数据库配置信息
 @param SDatabaseInfo & stFirstConnect 首链接
 @param std::vector<SDatabaseInfo> & vecLocalDBInfo 返回的本地数据库列表
 @param std::vector<SDatabaseInfo> & vecRemoteDBInfo 返回的远程数据库列表
 @return
 @retval
*/
int CSysInfoImp::getLocalDBInfo(SDatabaseInfo &stFirstConnect,
                                std::vector<SDatabaseInfo> &vecLocalDBInfo,
                                std::vector<SDatabaseInfo> &vecRemoteDBInfo)
{
    SNodeInfo stNodeInfo;
    if (iotSuccess != getLocalNodeInfo(stNodeInfo))
    {
        LOGERROR("getLocalDBInfo(): 未找到本机节点信息");
        return iotFailed;
    }

    return getDBInfoByDomainId(stNodeInfo.nDomainId, stFirstConnect, vecLocalDBInfo, vecRemoteDBInfo);
}

/**
 @brief 获取本机节点信息
 @param SNodeInfo & stNodeInfo 返回的节点信息
 @return
 @retval
*/
int CSysInfoImp::getLocalNodeInfo(SNodeInfo &stNodeInfo)
{
    const std::string strMyHostName = boost::asio::ip::host_name();
    return getNodeInfoByName(strMyHostName, stNodeInfo);
}

/**
 @brief 通过应用ID获取本进程运行所需的相关参数
 @param int nAppId  应用ID
 @param SRunAppInfo & stRunAppInfo 返回的运行信息
 @return
 @retval
*/
int CSysInfoImp::getLocalRunAppInfoById(int nAppId, SRunAppInfo &stRunAppInfo)
{
    //获取NodeInfo
    SNodeInfo stLocalNodeInfo;
    if (iotSuccess != getLocalNodeInfo(stLocalNodeInfo))
    {
        LOGERROR("getLocalRunAppInfoById(): 未找到本机节点信息");
        return iotFailed;
    }

    //获取AppInfo
    BOOST_AUTO(itAppInfo, m_objData.m_mapAppInfo.find(nAppId));
    if (m_objData.m_mapAppInfo.end() == itAppInfo)
    {
        LOGERROR("getLocalRunAppInfoById(): 未找到该应用 nAppId == %d", nAppId);
        return iotFailed;
    }

    //获取DomainInfo
    BOOST_AUTO(itDomInfo, m_objData.m_mapDomainInfo.find(stLocalNodeInfo.nDomainId));
    if (m_objData.m_mapDomainInfo.end() == itDomInfo)
    {
        LOGERROR("getLocalRunAppInfoById(): 未找到该域 nDomainId == %d", stLocalNodeInfo.nDomainId);
        return iotFailed;
    }

    //获取LocationInfo
    BOOST_AUTO(itLocatInfo, m_objData.m_mapLocationInfo.find(stLocalNodeInfo.nLocationId));
    if (m_objData.m_mapLocationInfo.end() == itLocatInfo)
    {
        LOGERROR("getLocalRunAppInfoById(): 未找到该位置 nLocationId == %d", stLocalNodeInfo.nLocationId);
        return iotFailed;
    }

    stRunAppInfo.nDomainId = stLocalNodeInfo.nDomainId;
    stRunAppInfo.bIsCenterDomain = itDomInfo->second.bIsCenter;
    stRunAppInfo.nAppId = nAppId;
    stRunAppInfo.strAppName = itAppInfo->second.strName;
    stRunAppInfo.nLocationId = stLocalNodeInfo.nLocationId;
    stRunAppInfo.bIsCenterLocation = itLocatInfo->second.bIsCenter;
    stRunAppInfo.strLocalNodeName = stLocalNodeInfo.strName;
    stRunAppInfo.strLocalNodeDesc = stLocalNodeInfo.strDesc;
    stRunAppInfo.eNodeType = stLocalNodeInfo.eNodeType;

    stRunAppInfo.setSubsystemId.clear();
    BOOST_FOREACH(const int i, itAppInfo->second.vecSubsystemId)
    {
        stRunAppInfo.setSubsystemId.insert(i);
    }

    return iotSuccess;
}

/**
 @brief 通过应用名获取本进程运行所需的相关参数
 @param const std::string & strSubsystemName 应用名
 @param SRunAppInfo & stRunAppInfo           返回的运行信息
 @return
 @retval
*/
int CSysInfoImp::getLocalRunAppInfoByName(const std::string &strAppName, SRunAppInfo &stRunAppInfo)
{
    SAppInfo stAppInfo;
    if (iotSuccess != getAppInfoByName(strAppName, stAppInfo))
    {
        LOGERROR("getLocalRunAppInfoByName(): 未找到该应用 strAppName == %s", strAppName.c_str());
        return iotFailed;
    }

    return getLocalRunAppInfoById(stAppInfo.nId, stRunAppInfo);
}

//----virtual int getAllDBDeploy(std::vector<SDBDeploy> &vecDBDeploy) = 0;
/**
 @brief 通过位置号获取位置信息
 @param int nLocationId 位置号
 @param SLocationInfo & stLocationInfo 返回的位置信息
 @return
 @retval
*/
int CSysInfoImp::getLocationInfoById(int nLocationId, SLocationInfo &stLocationInfo)
{
    BOOST_AUTO(it, m_objData.m_mapLocationInfo.find(nLocationId));
    if (m_objData.m_mapLocationInfo.end() == it)
    {
        LOGERROR("getLocationInfoById(): 未找到该位置 nLocationId == %d", nLocationId);
        return iotFailed;
    }

    stLocationInfo = it->second;
    return iotSuccess;
}

/**
 @brief 通过位置名称获取位置
 @param const std::string & strLocationName 位置名称
 @param SLocationInfo & stLocationInfo 返回的位置信息
 @return
 @retval
*/
int CSysInfoImp::getLocationInfoByName(const std::string &strLocationName, SLocationInfo &stLocationInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapLocationInfo.begin());
         it != m_objData.m_mapLocationInfo.end();
         it++)
    {
        if (strLocationName == it->second.strName)
        {
            stLocationInfo = it->second;
            return iotSuccess;
        }
    }

    LOGERROR("getLocationInfoByName(): 未找到该位置 strLocationName == %s", strLocationName.c_str());

    return iotFailed;
}

/**
 @brief 通过域ID获取该域下所有的位置信息
 @param int nDomainId 域号
 @param std::vector<SLocationInfo> & vecLocationInfo 返回的位置信息
 @return
 @retval
*/
int CSysInfoImp::getLocationListByDomainId(int nDomainId, std::vector<SLocationInfo> &vecLocationInfo)
{
    vecLocationInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapLocationInfo.begin());
         it != m_objData.m_mapLocationInfo.end();
         it++)
    {
        if (nDomainId == it->second.nDomainId)
        {
            vecLocationInfo.push_back(it->second);
        }
    }

    return iotSuccess;
}

/**
 @brief 通过节点名获取节点信息
 @param const std::string strNodeName 节点名
 @param SNodeInfo & stNodeInfo 返回的节点信息
 @return
 @retval
*/
int CSysInfoImp::getNodeInfoByName(const std::string strNodeName, SNodeInfo &stNodeInfo)
{
    BOOST_AUTO(it, m_objData.m_mapNodeInfo.find(strNodeName));
    if (m_objData.m_mapNodeInfo.end() == it)
    {
        LOGERROR("getNodeInfoByName(): 未找到该节点 strNodeName == [%s]", strNodeName.c_str());

        std::map<std::string, SNodeInfo>::iterator i;
        for ( i=m_objData.m_mapNodeInfo.begin(); i!=m_objData.m_mapNodeInfo.end(); i++ )
        {
            LOGERROR("现有节点：[%s]", i->second.strName.c_str());
        }

        return iotFailed;
    }

    stNodeInfo = it->second;
    return iotSuccess;
}

/**
 @brief 获取指定域的所有节点信息
 @param int nDomainId 域号
 @param std::vector<SNodeInfo> & vecNodeInfo 返回的节点列表
 @return
 @retval
*/
int CSysInfoImp::getNodeListByDomainId(int nDomainId, std::vector<SNodeInfo> &vecNodeInfo)
{
    vecNodeInfo.clear();
    for (BOOST_AUTO(it, m_objData.m_mapNodeInfo.begin());
         it != m_objData.m_mapNodeInfo.end();
         it++)
    {
        if (it->second.nDomainId == nDomainId)
        {
            vecNodeInfo.push_back(it->second);
        }
    }

    return iotSuccess;
}

/**
 @brief 获取指定域的所有节点信息
 @param const std::string & strDomainName 域名
 @param std::vector<SNodeInfo> & vecNodeInfo 返回的节点列表
 @return
 @retval
*/
int CSysInfoImp::getNodeListByDomainName(const std::string &strDomainName, std::vector<SNodeInfo> &vecNodeInfo)
{
    SDomainInfo stDomInfo;
    if (iotSuccess != getDomainInfoByName(strDomainName, stDomInfo))
    {
        LOGERROR("getNodeListByDomainName(): 未找到该域 strDomainName == %s", strDomainName.c_str());
        return iotFailed;
    }

    return getNodeListByDomainId(stDomInfo.nId, vecNodeInfo);
}

/**
 @brief 通过专业ID获取专业信息
 @param int nSubsystemId 专业ID
 @param SSubsystemInfo & stSubsystemInfo 返回的专业信息
 @return
 @retval
*/
int CSysInfoImp::getSubsystemInfoById(int nSubsystemId, SSubsystemInfo &stSubsystemInfo)
{
    BOOST_AUTO(it, m_objData.m_mapSubsystemInfo.find(nSubsystemId));
    if (m_objData.m_mapSubsystemInfo.end() == it)
    {
        LOGERROR("getSubsystemInfoById(): 未找到该专业 nSubsystemId = %d", nSubsystemId);
        return iotFailed;
    }

    stSubsystemInfo = it->second;
    return iotSuccess;
}

/**
 @brief 通过专业名获取专业信息
 @param const std::string & strSubsystemName 专业名称
 @param SSubsystemInfo & stSubsystemInfo 返回的专业信息
 @return
 @retval
*/
int CSysInfoImp::getSubsystemInfoByName(const std::string &strSubsystemName, SSubsystemInfo &stSubsystemInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapSubsystemInfo.begin());
         it != m_objData.m_mapSubsystemInfo.end();
         it++)
    {
        if (strSubsystemName == it->second.strName)
        {
            stSubsystemInfo = it->second;
            return iotSuccess;
        }
    }

    LOGERROR("getSubsystemInfoByName(): 未找到该专业 strSubsystemName == %s", strSubsystemName.c_str());
    return iotFailed;
}

/**
 @brief 获取指定应用下的专业列表
 @param int nAppId 应用ID
 @param std::vector<SSubsystemInfo> & vecSubsystemInfo 返回的专业信息列表
 @return
 @retval
*/
int CSysInfoImp::getSubsystemListByAppId(int nAppId, std::vector<SSubsystemInfo> &vecSubsystemInfo)
{
    vecSubsystemInfo.clear();
    SAppInfo stAppInfo;
    if (iotSuccess != getAppInfoById(nAppId, stAppInfo))
    {
        LOGERROR("getSubsystemListByAppId(): 未找到该应用 nAppId == %d", nAppId);
        return iotFailed;
    }

    for (size_t i = 0; i < stAppInfo.vecSubsystemId.size(); i++)
    {
        const int nSubSysId = stAppInfo.vecSubsystemId.at(i);
        BOOST_AUTO(it, m_objData.m_mapSubsystemInfo.find(nSubSysId));
        if (m_objData.m_mapSubsystemInfo.end() != it)
        {
            vecSubsystemInfo.push_back(it->second);
        }
    }

    return iotSuccess;
}

/**
 @brief 获取指定应用下的专业列表
 @param const std::string & strAppName 应用名
 @param std::vector<SSubsystemInfo> & vecSubsystemInfo 返回的专业信息列表
 @return
 @retval
*/
int CSysInfoImp::getSubsystemListByAppName(const std::string &strAppName, std::vector<SSubsystemInfo> &vecSubsystemInfo)
{
    vecSubsystemInfo.clear();
    SAppInfo stAppInfo;
    if (iotSuccess != getAppInfoByName(strAppName, stAppInfo))
    {
        LOGERROR("getSubsystemListByAppName(): 未找到该应用 strAppName == %s", strAppName.c_str());
        return iotFailed;
    }

    for (size_t i = 0; i < stAppInfo.vecSubsystemId.size(); i++)
    {
        const int nSubSysId = stAppInfo.vecSubsystemId.at(i);
        BOOST_AUTO(it, m_objData.m_mapSubsystemInfo.find(nSubSysId));
        if (m_objData.m_mapSubsystemInfo.end() != it)
        {
            vecSubsystemInfo.push_back(it->second);
        }
    }

    return iotSuccess;
}

/* @brief 获取本节点部署的各应用下的进程列表 */
int CSysInfoImp::getLocalProcInfoList(SProcessInfoMAP &mapProcInfo)
{
    std::vector<SAppDeploy> vecAppDeploy;
    if (iotSuccess != getLocalAppDeploy(vecAppDeploy))
    {
        LOGERROR("getLocalProcInfoList(): 未找到本节点应用部署信息");
        return iotFailed;
    }

    SProcessInfoSeq vecProcInfo;
    for (BOOST_AUTO(pAppIter, vecAppDeploy.begin()); pAppIter != vecAppDeploy.end(); ++pAppIter)
    {
        mapProcInfo[pAppIter->nAppId] = vecProcInfo;
    }

    for (BOOST_AUTO(it, m_objData.m_mapProcessInfo.begin()); it != m_objData.m_mapProcessInfo.end(); ++it)
    {
        SProcessInfoMAP::iterator pProcInfoIter = mapProcInfo.find(it->second.nAppId);
        if (pProcInfoIter != mapProcInfo.end())
        {
            pProcInfoIter->second.push_back(it->second);
        }
    }

    return iotSuccess;
}

/* @brief 获取指定应用部署的进程列表 */
int CSysInfoImp::getProcInfoListByAppId(int nAppId, SProcessInfoMAP &mapProcInfo)
{
    for (BOOST_AUTO(it, m_objData.m_mapProcessInfo.begin()); it != m_objData.m_mapProcessInfo.end(); ++it)
    {
        if (it->second.nAppId == nAppId)
        {
            mapProcInfo[it->second.nAppId].push_back(it->second);
        }
    }

    return iotSuccess;
}

/**
 @brief 获取所有消息总线转发信息
 @param vecMbRelayInfo:输出
 @return 成功返回iotSuccess，失败返回错误码
 @retval 
*/
int CSysInfoImp::getAllMbRelayInfo(std::vector<SMbRelayInfo> &vecMbRelayInfo)
{
    vecMbRelayInfo.clear();

    for (BOOST_AUTO(itMap, m_objData.m_mapMbRelayInfo.begin());
         m_objData.m_mapMbRelayInfo.end() != itMap;
         itMap++)
    {
        vecMbRelayInfo.push_back(itMap->second);
    }

    return iotSuccess;
}

/**
 @brief 按源域ID获取消息总线转发信息
 @param vecMbRelayInfo：输出
 @return 成功返回iotSuccess，失败返回错误码
 @retval 
*/
int CSysInfoImp::getMbRelayInfoBySrcDomainID(int nSrcDomainID,
                                             std::vector<SMbRelayInfo> &vecMbRelayInfo)
{
    vecMbRelayInfo.clear();

    for (BOOST_AUTO(itMap, m_objData.m_mapMbRelayInfo.begin());
         m_objData.m_mapMbRelayInfo.end() != itMap;
         itMap++)
    {
        const SMbRelayInfo &stMbRelayInfo = itMap->second;
        if (stMbRelayInfo.m_nSrcDomainID == nSrcDomainID)
        {
            vecMbRelayInfo.push_back(stMbRelayInfo);
        }
    }

    return iotSuccess;
}

/**
 @brief 按目标域ID获取消息总线转发信息
 @param vecMbRelayInfo：输出
 @return 成功返回iotSuccess，失败返回错误码
 @retval 
*/
int CSysInfoImp::getMbRelayInfoByDstDomainID(int nDstDomainID,
                                             std::vector<SMbRelayInfo> &vecMbRelayInfo)
{
    vecMbRelayInfo.clear();

    for (BOOST_AUTO(itMap, m_objData.m_mapMbRelayInfo.begin());
         m_objData.m_mapMbRelayInfo.end() != itMap;
         itMap++)
    {
        const SMbRelayInfo &stMbRelayInfo = itMap->second;
        if (stMbRelayInfo.m_nDstDomainID == nDstDomainID)
        {
            vecMbRelayInfo.push_back(stMbRelayInfo);
        }
    }

    return iotSuccess;
}

/**
 @brief 按目标域ID获取消息总线转发信息
 @param objMbRelayInfo：输出
 @return 成功返回iotSuccess，失败返回错误码
 @retval 
*/
int CSysInfoImp::getMbRelayInfoBySrcAndDstDomainID(int nSrcDomainID, int nDstDomainID,
                                                   SMbRelayInfo &stMbRelayInfo)
{
    //< “nSrcDomainID-nDstDomainID”作为key
    const std::string strKey = boost::str(boost::format("%d-%d")
                                          % nSrcDomainID % nDstDomainID);

    BOOST_AUTO(itMap, m_objData.m_mapMbRelayInfo.find(strKey));
    if (m_objData.m_mapMbRelayInfo.end() == itMap)
    {
        LOGERROR("getMbRelayInfoBySrcAndDstDomainID(): 未找到转发配置 nSrcDomainID == %d, nDstDomainID == %d",
                 nSrcDomainID, nDstDomainID);
        return iotFailed;
    }

    stMbRelayInfo = itMap->second;

    return iotSuccess;
}

/**
 * @brief getUniqueIdOfNodeInfo 获取所有节点信息的唯一id，用于在同一个网络内区分不同的项目
 * @return CRC32值
 */
unsigned int CSysInfoImp::getUniqueIdOfNodeInfo()
{
    unsigned int nRet = 0;
    std::vector<SNodeInfo> vecNodeInfo;
    if ( iotSuccess != getAllNodeInfo(vecNodeInfo) || vecNodeInfo.size() <= 0 )
        return nRet;

    // 按节点名排序
    std::sort( vecNodeInfo.begin(), vecNodeInfo.end(), [](const SNodeInfo& objNode0,const SNodeInfo& objNode1){
        return objNode0.strName < objNode1.strName;
    } );

    // 将所有节点配置组合成一个字符串
    std::string sInfo = "";
    for ( size_t i=0; i<vecNodeInfo.size(); i++ )
    {
        sInfo = sInfo + vecNodeInfo.at(i).strName + ";" + vecNodeInfo.at(i).strNic1Addr + ";" +
                vecNodeInfo.at(i).strNic2Addr + ";";
    }

    // 获取字符串crc
    nRet = calcCRC32( (unsigned char*)sInfo.c_str(), static_cast<int>(sInfo.size()) );

    // 基本不可能发生，以防万一，不，是以防43亿分之一
    if ( nRet == 0 )
    {
        LOGERROR("CRC算出来的值是0，去买彩票吧！！！！！！！！");
    }

    return nRet;
}

} //namespace iot_public