CMakeLists.txt

@@ -14,6 +14,7 @@ add_compile_options(-DRELEASE)
 option(build_modules "build modules" ON)
 option(build_source "build source programs" ON)
 option(build_plugins "build plugins programs" ON)
+option(build_test "build test programs" OFF)
 
 add_subdirectory(framework)
 if(build_modules)
@@ -25,6 +26,9 @@ endif()
 if(build_source)
   add_subdirectory(source)
 endif()
+if(build_test)
+  add_subdirectory(test)
+endif()
 
 # ---[ install
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib")  #set runtime path

framework/request/include/HepuHB.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuHB
+{
+    private:
+    public:
+        const string cmd = "userOnlineHeart";
+        string token;
+
+        HepuHB(){};
+        ~HepuHB(){};
+        void objectToJson(string& str){
+            rapidjson::StringBuffer strBuf;
+            rapidjson::Writer<rapidjson::StringBuffer> writer(strBuf);
+            this->objectToJson(writer);
+            str = strBuf.GetString();
+        }
+
+        void objectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer){
+            writer.StartObject();
+
+            writer.Key("cmd");
+            writer.String(cmd.c_str());
+
+            writer.Key("param");
+            writer.StartObject();
+
+            writer.Key("token");
+            writer.String(token.c_str());
+            writer.EndObject();
+
+            writer.EndObject();
+        }
+
+        bool jsonToObject(std::string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }
+
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("token") || !doc["token"].IsInt()){
+                    return false;
+                }else{
+                    token = doc["token"].GetString();
+                }
+            }
+
+            return true;
+        }
+};

framework/request/include/HepuHBRe.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuHBRe
+{
+    private:
+    public:
+        const string cmd = "userOnlineHeart";
+        int ackvalue ;
+
+        HepuHBRe(){};
+        ~HepuHBRe(){};
+
+        bool jsonToObject(string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }
+            
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("ackvalue") || !doc["ackvalue"].IsInt()) {
+                    return false;
+                }else{
+                    ackvalue = doc["ackvalue"].GetInt();
+                }
+            }
+            return true;
+        }
+};

framework/request/include/HepuLogin.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuLogin
+{
+    private:
+    public:
+        const string cmd = "userLogin";
+        string token;
+        string username;
+        string password;
+        HepuLogin(){};
+        ~HepuLogin(){};
+        
+        void objectToJson(string& str){
+            rapidjson::StringBuffer strBuf;
+            rapidjson::Writer<rapidjson::StringBuffer> writer(strBuf);
+            this->objectToJson(writer);
+            str = strBuf.GetString();
+        }
+
+        void objectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer){
+            writer.StartObject();
+
+            writer.Key("cmd");
+            writer.String(cmd.c_str());
+
+            writer.Key("param");
+            writer.StartObject();
+
+            writer.Key("token");
+            writer.String(token.c_str());
+
+            writer.Key("username");
+            writer.String(username.c_str());
+
+            writer.Key("password");
+            writer.String(password.c_str());
+            writer.EndObject();    
+
+            writer.EndObject();
+        }
+
+        bool jsonToObject(std::string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }
+            
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("token") || !doc["token"].IsString()) {
+                    return false;
+                }else{
+                    token = doc["token"].GetString();
+                }
+
+                if(end == doc.FindMember("username") || !doc["username"].IsString()) {
+                    return false;
+                }else{
+                    username = doc["username"].GetString();
+                }
+
+                if(end == doc.FindMember("password") || !doc["password"].IsString()) {
+                    return false;
+                }else{
+                    password = doc["password"].GetString();
+                }
+            }
+  
+            return true;
+        }
+};

framework/request/include/HepuLoginRe.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuLoginRe
+{
+    private:
+    public:
+        const string cmd = "userLogin";
+        int ackvalue;    
+        string token;
+        HepuLoginRe(){};
+        ~HepuLoginRe(){};
+
+        bool jsonToObject(string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }
+
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("ackvalue") || !doc["ackvalue"].IsInt()) {
+                    return false;
+                }else{
+                    ackvalue = doc["token"].GetInt();
+                }   
+
+                if(end == doc.FindMember("token") || !doc["token"].IsString()) {
+                    return false;
+                }else{
+                    token = doc["token"].GetString();
+                }
+            }
+
+            return true;
+        }
+};

framework/request/include/HepuTarget.h

@@ -0,0 +1,150 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuTarget
+{
+    private:
+    public:
+        const string cmd = "ivpTrackingCtrl";
+        string token;
+        bool bTracking;
+        int channelid;
+        int trackingTime;
+        struct TrackingRect{
+            int x;
+            int y;
+            int w;
+            int h;
+        };
+        TrackingRect trackingRect;
+        
+        HepuTarget(){};
+        ~HepuTarget(){};
+        void objectToJson(string& str){
+            rapidjson::StringBuffer strBuf;
+            rapidjson::Writer<rapidjson::StringBuffer> writer(strBuf);
+            this->objectToJson(writer);
+            str = strBuf.GetString();
+        }
+
+        void objectToJson(rapidjson::Writer<rapidjson::StringBuffer>& writer){
+            writer.StartObject();
+
+            writer.Key("cmd");
+            writer.String(cmd.c_str());
+
+            writer.Key("param");
+            writer.StartObject();
+
+            writer.Key("token");
+            writer.String(token.c_str());
+
+            writer.Key("bTracking");
+            writer.Bool(bTracking);
+
+            writer.Key("channelid");
+            writer.Int(channelid);
+
+            writer.Key("trackingTime");
+            writer.Int(trackingTime);
+
+            writer.Key("trackingRect");
+            
+            writer.StartObject();
+            writer.Key("x");
+            writer.Int(trackingRect.x);
+
+            writer.Key("y");
+            writer.Int(trackingRect.y);
+
+            writer.Key("w");
+            writer.Int(trackingRect.w);
+
+            writer.Key("h");
+            writer.Int(trackingRect.h);
+            writer.EndObject();
+
+            writer.EndObject();
+
+            writer.EndObject();
+        }
+
+        bool jsonToObject(std::string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }            
+
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("token") || !doc["token"].IsString()) {
+                    return false;
+                }else{
+                    token = doc["token"].GetString();
+                }
+
+                if(end == doc.FindMember("bTracking") || !doc["bTracking"].IsBool()) {
+                    return false;
+                }else{
+                    bTracking = doc["bTracking"].GetBool();
+                }
+
+                if(end == doc.FindMember("channelid") || !doc["channelid"].IsInt()) {
+                    return false;
+                }else{
+                    channelid = doc["channelid"].GetInt();
+                }
+
+                if(end == doc.FindMember("trackingTime") || !doc["trackingTime"].IsInt()) {
+                    return false;
+                }else{
+                    trackingTime = doc["trackingTime"].GetInt();
+                }
+
+                if(end == doc.FindMember("trackingRect") || !doc["trackingRect"].IsObject()) {
+                    return false;
+                }else{
+                    if(end == doc.FindMember("x") || !doc["x"].IsInt()) {
+                        return false;
+                    }else{
+                        trackingRect.x = doc["x"].GetInt();
+                    }
+                    if(end == doc.FindMember("y") || !doc["y"].IsInt()) {
+                        return false;
+                    }else{
+                        trackingRect.y = doc["y"].GetInt();
+                    }
+                    if(end == doc.FindMember("w") || !doc["w"].IsInt()) {
+                        return false;
+                    }else{
+                        trackingRect.w = doc["w"].GetInt();
+                    }
+                    if(end == doc.FindMember("h") || !doc["h"].IsInt()) {
+                        return false;
+                    }else{
+                        trackingRect.h = doc["h"].GetInt();
+                    }
+                }
+            }
+
+            return true;
+        }
+};

framework/request/include/HepuTargetRe.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <iostream>
+
+#include <rapidjson/document.h>
+#include <rapidjson/rapidjson.h>
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+using namespace std;
+
+class HepuTargetRe
+{
+    private:
+    public:
+        const string cmd = "ivpTrackingCtrl";
+        int ackvalue;
+        int channelid;
+        bool bTracking;
+        
+        HepuTargetRe(){};
+        ~HepuTargetRe(){};
+
+        bool jsonToObject(string& json){
+            rapidjson::Document doc;
+            doc.Parse(json.c_str());
+            if(!doc.IsObject()){
+                return false;
+            }
+
+            const auto end = doc.MemberEnd();
+
+            if(end == doc.FindMember("cmd") || !doc["cmd"].IsString()){
+                return false;
+            }else{
+                if(cmd != doc["cmd"].GetString())
+                    return false;
+            }
+
+            if(end == doc.FindMember("param") || !doc["param"].IsObject()) {
+                return false;
+            }else{
+                if(end == doc.FindMember("ackvalue") || !doc["ackvalue"].IsInt()) {
+                    return false;
+                }else{
+                    ackvalue = doc["ackvalue"].GetInt();
+                }
+
+                if(end == doc.FindMember("channelid") || !doc["channelid"].IsInt()) {
+                    return false;
+                }else{
+                    channelid = doc["channelid"].GetInt();
+                }
+
+                if(end == doc.FindMember("bTracking") || !doc["bTracking"].IsBool()) {
+                    return false;
+                }else{
+                    bTracking = doc["bTracking"].GetBool();
+                }
+            }
+            return true;
+        }
+};

framework/request/include/requests.hpp

@@ -21,6 +21,9 @@
 #include "RecDeviceCommand.h"
 #include "RecLoginMsg.h"
 
+#include "HepuHB.h"
+#include "HepuLogin.h"
+#include "HepuTarget.h"
 
 #include "SendBird.h"
 #include "SendDevice.h"

modules/CMakeLists.txt

@@ -24,7 +24,8 @@ option(build_TCPClient "build module TCPClient" ON)
 option(build_config "build module config" ON)
 option(build_HttpServer "build module HttpServer" ON)
 option(build_Audit "build module Audit" ON)
-option(build_kafka           "build module kafka" ON)
+option(build_kafka "build module kafka" ON)
+option(build_Hepu "build module Hepu" ON)
 
 # ---[ 3rdparty
 set(3RDPARTY_LIBS "")
@@ -83,6 +84,11 @@ if(build_HttpServer)
   include_directories(${PROJECT_SOURCE_DIR}/modules/HttpServer/src)
   install(DIRECTORY HttpServer/include/ DESTINATION include)
 endif()
+if(build_Hepu)
+  list(APPEND module_list Hepu)
+  include_directories($(PROJECT_SOURCE_DIR)/modules/Hepu/src)
+  install(DIRECTORY Hepu/include/ DESTINATION include)
+endif()
 if(build_Audit)
   list(APPEND module_list Audit)
   include_directories(${PROJECT_SOURCE_DIR}/modules/Audit/src)

modules/Hepu/include/Hepu.hpp

@@ -0,0 +1,69 @@
+#ifndef __HEPU_H__
+#define __HEPU_H__
+
+#include <iostream>
+#include <time.h>
+#include <ctime>
+
+#include "Util/logger.h"
+#include "Util/NoticeCenter.h"
+#include "Poller/EventPoller.h"
+#include "Util/SqlPool.h"
+#include "Network/TcpClient.h"
+#include "Poller/Timer.h"
+#include "TCPClient.hpp"
+#include <httplib.h>
+#include "Notices.h"
+
+#include "UtilBase.hpp"
+
+#include "HepuHB.h"
+#include "HepuHBRe.h"
+#include "HepuLogin.h"
+#include "HepuLoginRe.h"
+#include "HepuTarget.h"
+#include "HepuTargetRe.h"
+
+using namespace std;
+
+namespace gsd{
+
+    class Hepu: public enable_shared_from_this<Hepu>, public ModuleBase
+    {
+        private:
+
+            string username;
+            string password;
+            string token;
+
+        public:
+            Hepu(){}
+            ~Hepu(){}
+
+            virtual bool Init(){
+                return true;
+            }
+
+            virtual void Destroy(){
+
+            }
+
+            int32_t Init(string username, string url, int port);
+
+            static std::shared_ptr<Hepu> CreateNew();
+
+            int32_t LoginHepu();
+
+            bool alive();
+
+            int32_t sendHepuHB(HepuHB& HepuHBMsg);
+
+            int32_t sendHepuHB();
+
+            int32_t sendHepuTarget(HepuTarget& HepuTargetMsg);
+
+    };
+};
+
+
+#endif

modules/Hepu/src/Hepu.cpp

@@ -0,0 +1,150 @@
+#include "Hepu.hpp"
+
+namespace gsd{
+    std::shared_ptr<httplib::Client> m_hepu = nullptr;
+
+    std::shared_ptr<Hepu> Hepu::CreateNew(){
+        static shared_ptr<Hepu> hepu = nullptr;
+        if(hepu == nullptr) 
+            hepu = std::make_shared<Hepu>();
+        return hepu;
+    }
+
+    int32_t Hepu::Init(std::string username, std::string url, int port){
+        this->username = username;
+        m_hepu = std::make_shared<httplib::Client>(url, port);
+        if(m_hepu == NULL){
+            ErrorL << "Hepu http client initialization failed.";
+            return ERR;
+        }
+        if(this->LoginHepu() != OK){
+            ErrorL << "Failed to login to Hepu IPC.";
+            return ERR;
+        }
+        return OK;
+    }
+
+    int32_t Hepu::LoginHepu(){
+        if(m_hepu == nullptr) return ERR;
+
+        HepuLogin hepuloginMsg;
+        std::string msg;
+        hepuloginMsg.token = "";
+        hepuloginMsg.username = this->username;
+        hepuloginMsg.password = this->password;
+        hepuloginMsg.objectToJson(msg);
+        msg += "\r\n";
+
+        if(auto res = m_hepu->Post("/cgi-bin/proc.cgi", msg,"application/json")){
+            if(res->status != 100){
+                HepuLoginRe hepuloginReMsg;
+                if(!hepuloginReMsg.jsonToObject(res->body)){
+                    return ERR;
+                }
+                if(hepuloginReMsg.ackvalue != 100){
+                    return ERR;
+                }
+                if(hepuloginReMsg.token.size()){
+                    this->token = hepuloginReMsg.token;
+                    return OK;
+                }
+                return ERR;
+            }
+            return ERR;
+        }else{
+            auto err = res.error();
+            ErrorL << "The service is not available,"<<err<<endl;
+            return ERR;
+        }
+        return ERR;
+    }
+
+    bool Hepu::alive(){
+        return this->token == "" ? false : true;
+    }
+
+    int32_t Hepu::sendHepuHB(HepuHB& hepuHBMsg){
+        if(m_hepu == nullptr) return ERR;
+
+        std::string msg;
+        hepuHBMsg.token = this->token;
+        hepuHBMsg.objectToJson(msg);
+        msg+="\r\n";
+
+        if(auto res = m_hepu->Post("/cgi-bin/proc.cgi", msg,"application/json")){
+            if(res->status != 100){
+                HepuHBRe hepuHBReMsg;
+                if(!hepuHBReMsg.jsonToObject(res->body)){
+                    return ERR;
+                }
+                if(hepuHBReMsg.ackvalue != 100){
+                    return ERR;
+                }
+                return OK;
+            }
+            return ERR;
+        }else{
+            auto err = res.error();
+            ErrorL << "Hepu Heartbeat failed,"<<err<<endl;
+            return ERR;
+        }
+        return ERR;
+    }
+
+    int32_t Hepu::sendHepuHB(){
+        if(m_hepu == nullptr) return ERR;
+
+        HepuHB hepuHBMsg;
+        std::string msg;
+        hepuHBMsg.token = this->token;
+        hepuHBMsg.objectToJson(msg);
+        msg+="\r\n";
+
+        if(auto res = m_hepu->Post("/cgi-bin/proc.cgi", msg,"application/json")){
+            if(res->status != 100){
+                HepuHBRe hepuHBReMsg;
+                if(!hepuHBReMsg.jsonToObject(res->body)){
+                    return ERR;
+                }
+                if(hepuHBReMsg.ackvalue != 100){
+                    return ERR;
+                }
+                return OK;
+            }
+            return ERR;
+        }else{
+            auto err = res.error();
+            ErrorL << "Hepu Heartbeat failed,"<<err<<endl;
+            return ERR;
+        }
+        return ERR;
+    }
+
+    int32_t Hepu::sendHepuTarget(HepuTarget& HepuTargetMsg){
+        if(m_hepu == nullptr) return ERR;
+
+        std::string msg;
+        HepuTargetMsg.token = this->token;
+        HepuTargetMsg.objectToJson(msg);
+        msg+="\r\n";
+
+        if(auto res = m_hepu->Post("/cgi-bin/proc.cgi", msg,"application/json")){
+            if(res->status != 100){
+                HepuTargetRe hepuTargetReMsg;
+                if(!hepuTargetReMsg.jsonToObject(res->body)){
+                    return ERR;
+                }
+                if(hepuTargetReMsg.ackvalue != 100){
+                    return ERR;
+                }
+                return OK;
+            }
+            return ERR;
+        }else{
+            auto err = res.error();
+            ErrorL << "Hepu Heartbeat failed,"<<err<<endl;
+            return ERR;
+        }
+        return ERR;
+    }
+}