GrpcPrint/PrintS/DataManage/StreamServer.h

#pragma once
#include <thread>
#include <vector>
#include <string>
#include <grpcpp/grpcpp.h>
#include <grpc/support/log.h>
#include "../protobuf/stream.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using stream::Stream;
using stream::RequestInfo;
using stream::ResponseInfo;


enum READTYPE {
    GET = 0,
    SET,
    LOAD,  //载入
    LOADOUT,  //载出
    SUPPLYAXLEAFTER,  //供粉轴后移
    SUPPLYAXLEFRONT,  //供粉轴前移
    SUPPLYAXLEAFTERCONT,  //供粉轴后移连续
    SUPPLYAXLEFRONTCONT,  //供粉轴前移连续
    PAVEAXLEFRONT,     // 铺粉臂前移
    PAVEAXLEFRONTCONT,  //铺粉臂前移连续
    PAVEAXLEAFTER,  //铺粉臂后移
    PAVEAXLEAFTERCONT,  //铺粉臂后移连续
    PAVEAXLECLEAR,  //铺粉臂清零
    PRINTAXLEUP,     //成型缸上升
    PRINTAXLEUPCONT,  //成型缸连续上升
    PRINTAXLEDOWN,   //成型缸下降
    PRINTAXLEDOWNCONT,   //成型缸连续下降
    PRINTAXLECLEAR,  //成型缸清零
    TRANSFERAXIELEFT,    //移栽轴左移
    TRANSFERAXIELEFTCONT,    //移栽轴连续左移
    TRANSFERAXIERIGHT,    //移栽轴右移
    TRANSFERAXIERIGHTCONT,    //移栽轴连续右移
    TRANSFERAXIECLEAR     //移栽轴清零  
};

enum DATATYPE {
    iBOOL,
    iSHORT,
    iUSHORT,
    iINT,
    iUINT,
    iFLOAT
};

typedef class ClientInfo;
struct ReadData {
    READTYPE  dataType;
    std::string   nameKey;      //参数key
    std::string    strValue;    //value
    DATATYPE  valueType;
    ClientInfo* clientPtr;
};

enum WRITETYPE {
    ALARM = 0,     //报警  
    RESPOND,   //回应
    TIMEDATA  //定时数据
};


struct WriteData {
    WRITETYPE  dataType;
    bool  result;
    std::string nameKey;   //参数key
    std::string  strValue;    //value
    DATATYPE  valueType;  //数据类型
};


class ClientInfo {
public:
    ClientInfo()
        : m_clientAddr("0.0.0.0:0")
        , m_readQuitFlag(false)
        , m_writeQuitFlag(false)
        , m_context(nullptr){
    
    }

    ~ClientInfo() {
        m_readQuitFlag = true;
        m_writeQuitFlag = true;
    }

    bool IsConnect() {
        return m_context && !m_context->IsCancelled();
    }

    bool GetPushMsg(WriteData& msg) {
        std::lock_guard<std::mutex> lock(m_msgLock);
        if (m_msgList.empty()) {
            return false;
        }
        else {
            msg = (*m_msgList.front());
            m_msgList.pop_front();
            return true;
        }
    }


    void SetPushMsg(WriteData* msg) {
        std::lock_guard<std::mutex> lock(m_msgLock);
        m_msgList.push_back(msg);
    }

public:
    std::string m_clientAddr;
    bool  m_readQuitFlag;
    bool  m_writeQuitFlag;
    ServerContext* m_context;

private:
    std::list<WriteData*> m_msgList;   //信息缓存区
    std::mutex  m_msgLock;     //信息锁
};



class StreamServer final : public Stream::Service {
    typedef void (*DataCallBack)(void* pthis,const ReadData& msg);
public:
    StreamServer();
    ~StreamServer();

    void Run();

    void SetCallBackFunc(void* pdata,DataCallBack dataCallBack) {
        m_dataCallBack = dataCallBack;
        m_handlePtr = pdata;
    }

    ClientInfo* GetClient() {
        std::lock_guard<std::mutex> lck(m_clientMutex);
        return m_clientList.front();
    }

    void CheckProc();
private:
    Status AllStream(ServerContext* context, grpc::ServerReaderWriter<ResponseInfo, RequestInfo>* stream) override;

private:
    std::mutex  m_clientMutex;
    std::list<ClientInfo*> m_clientList;

    std::thread m_checkCloseTd;  //检测客户端关闭线程
    bool m_checkQuitFlag;
    DataCallBack m_dataCallBack;

    int m_port;   //监听端口
    void* m_handlePtr;
};