add api BHQueryProcs.

lichao

2021-05-19 34cd75f77d0ca94dbdba4e6cc9451fe4d33e78b3

 src/topic_node.h

@@ -19,9 +19,11 @@
#define TOPIC_NODE_YVKWA6TF

#include "msg.h"
#include "pubsub.h"
#include "socket.h"
#include <atomic>
#include <memory>
#include <mutex>
#include <vector>

using namespace bhome_shm;
using namespace bhome_msg;
@@ -30,92 +32,164 @@
class TopicNode
{
   SharedMemory &shm_;
   MsgRegister info_;
   ProcInfo info_;

   SharedMemory &shm() { return shm_; }

public:
   TopicNode(SharedMemory &shm);
   ~TopicNode();
   bool Register(const MsgRegister &body, MsgCommonReply &reply, const int timeout_ms);
   bool RegisterRPC(const MsgRegisterRPC &body, MsgCommonReply &reply, const int timeout_ms);

   // topic node
   bool Register(ProcInfo &proc, MsgCommonReply &reply_body, const int timeout_ms);
   bool Unregister(ProcInfo &proc, MsgCommonReply &reply_body, const int timeout_ms);
   bool Heartbeat(ProcInfo &proc, MsgCommonReply &reply_body, const int timeout_ms);
   bool Heartbeat(const int timeout_ms);
   bool QueryTopicAddress(BHAddress &dest, MsgQueryTopic &query, MsgQueryTopicReply &reply_body, const int timeout_ms);
   bool QueryProcs(BHAddress &dest, MsgQueryProc &query, MsgQueryProcReply &reply_body, const int timeout_ms);

   // topic rpc server
   typedef std::function<bool(const std::string &topic, const std::string &data, std::string &reply)> OnRequest;
   bool ServerStart(OnRequest const &cb, const int nworker = 2);
   bool ServerStop();
   bool ServerRecvRequest(void *&src_info, std::string &topic, std::string &data, const int timeout_ms);
   bool ServerSendReply(void *src_info, const std::string &data, const int timeout_ms);
   typedef std::function<bool(const std::string &client_proc_id, const MsgRequestTopic &request, MsgRequestTopicReply &reply)> ServerSyncCB;
   typedef std::function<void(void *src_info, std::string &client_proc_id, MsgRequestTopic &request)> ServerAsyncCB;
   bool ServerStart(ServerSyncCB const &cb, const int nworker = 2);
   bool ServerStart(ServerAsyncCB const &cb, const int nworker = 2);
   bool ServerRegisterRPC(MsgTopicList &topics, MsgCommonReply &reply, const int timeout_ms);
   bool ServerRecvRequest(void *&src_info, std::string &proc_id, MsgRequestTopic &request, const int timeout_ms);
   bool ServerSendReply(void *src_info, const MsgRequestTopicReply &reply);

   // topic client
   typedef std::function<void(const std::string &data)> RequestResultCB;
   typedef std::function<void(const BHMsgHead &head, const MsgRequestTopicReply &reply)> RequestResultCB;
   bool ClientStartWorker(RequestResultCB const &cb, const int nworker = 2);
   bool ClientStopWorker();
   bool ClientAsyncRequest(const Topic &topic, const void *data, const size_t size, const int timeout_ms, const RequestResultCB &rrcb = RequestResultCB());
   bool ClientAsyncRequest(const Topic &topic, const std::string &data, const int timeout_ms, const RequestResultCB &rrcb = RequestResultCB())
   {
      return ClientAsyncRequest(topic, data.data(), data.size(), timeout_ms, rrcb);
   }
   bool ClientSyncRequest(const Topic &topic, const void *data, const size_t size, std::string &out, const int timeout_ms);
   bool ClientSyncRequest(const Topic &topic, const std::string &data, std::string &out, const int timeout_ms)
   {
      return ClientSyncRequest(topic, data.data(), data.size(), out, timeout_ms);
   }
   bool ClientAsyncRequest(const BHAddress &remote_addr, const MsgRequestTopic &request, std::string &msg_id, const RequestResultCB &rrcb = RequestResultCB());
   bool ClientSyncRequest(const BHAddress &remote_addr, const MsgRequestTopic &request, std::string &proc_id, MsgRequestTopicReply &reply, const int timeout_ms);

   void StopAll();
   // publish
   bool Publish(const MsgPublish &pub, const int timeout_ms);

   // subscribe
   typedef std::function<void(const std::string &proc_id, const MsgPublish &data)> SubDataCB;
   bool SubscribeStartWorker(const SubDataCB &tdcb, int nworker = 2);
   bool Subscribe(MsgTopicList &topics, MsgCommonReply &reply_body, const int timeout_ms);
   bool RecvSub(std::string &proc_id, MsgPublish &pub, const int timeout_ms);

   void Start(ServerAsyncCB const &server_cb, SubDataCB const &sub_cb, RequestResultCB &client_cb, int nworker = 2);
   void Stop();

private:
   bool ClientQueryRPCTopic(const Topic &topic, bhome::msg::BHAddress &addr, const int timeout_ms);
   const std::string &proc_id() { return info_.proc().proc_id(); }
   MQId ssn() { return SockNode().id(); }
   bool ClientQueryRPCTopic(const Topic &topic, BHAddress &addr, const int timeout_ms);
   typedef MsgQueryTopicReply::BHNodeAddress NodeAddress;
   int QueryTopicServers(const Topic &topic, std::vector<NodeAddress> &addr, const int timeout_ms);
   const std::string &proc_id() { return info_.proc_id(); }

   typedef bhome_msg::BHAddress Address;
   typedef BHAddress Address;
   class TopicQueryCache
   {
      class Impl
      {
         typedef std::unordered_map<Topic, Address> Store;
         Store store_;
         struct TimedRec {
            Address addr_;
            int64_t timestamp_;
         };
         typedef std::unordered_map<Topic, TimedRec> Records;
         Records records_;

      public:
         bool Find(const Topic &topic, Address &addr)
         {
            auto pos = store_.find(topic);
            if (pos != store_.end()) {
               addr = pos->second;
               return true;
            } else {
               return false;
            auto pos = records_.find(topic);
            if (pos != records_.end()) {
               if (NowSec() - pos->second.timestamp_ < NodeTimeoutSec() / 2) {
                  addr = pos->second.addr_;
                  return true;
               } else {
                  LOG_TRACE() << "topic dest cache timeout.";
               }
            }
            return false;
         }
         bool Update(const Topic &topic, const Address &addr)
         bool Store(const Topic &topic, const Address &addr)
         {
            store_[topic] = addr;
            records_[topic] = {addr, NowSec()};
            return true;
         }
      };
      Synced<Impl> impl_;
      // Impl &impl()
      // {
      //    thread_local Impl impl;
      //    return impl;
      // }

   public:
      bool Find(const Topic &topic, Address &addr) { return impl_->Find(topic, addr); }
      bool Update(const Topic &topic, const Address &addr) { return impl_->Update(topic, addr); }
      bool Store(const Topic &topic, const Address &addr) { return impl_->Store(topic, addr); }
   };

   // some sockets may be the same one, using functions make it easy to change.
   enum { eSockStart,
         eSockNode = eSockStart,
         eSockPub = eSockNode,
         eSockServer,
         eSockClient,
         eSockSub,
         eSockEnd,
   };
   std::vector<std::shared_ptr<ShmSocket>> sockets_;

   auto &SockNode() { return sock_node_; }
   auto &SockSub() { return sock_sub_; }
   auto &SockRequest() { return sock_request_; }
   auto &SockReply() { return sock_reply_; }
   ShmSocket &SockNode() { return *sockets_[eSockNode]; }
   ShmSocket &SockPub() { return *sockets_[eSockPub]; }
   ShmSocket &SockSub() { return *sockets_[eSockSub]; }
   ShmSocket &SockClient() { return *sockets_[eSockClient]; }
   ShmSocket &SockServer() { return *sockets_[eSockServer]; }

   ShmSocket sock_node_;
   ShmSocket sock_request_;
   ShmSocket sock_reply_;
   SocketSubscribe sock_sub_;
   void SetProcIndex(int index)
   {
      proc_index_ = index;
      for (int i = eSockStart; i < eSockEnd; ++i) {
         sockets_[i]->SetNodeProc(index, i);
      }
   }

   enum State {
      eStateUninited,
      eStateUnregistered,
      eStateOnline,
      eStateOffline // heartbeat fail.
   };
   void state(const State st) { state_.store(st); }
   void state_cas(State expected, const State val) { state_.compare_exchange_strong(expected, val); }
   State state() const { return state_.load(); }
   bool IsOnline() { return state() == eStateOnline; }
   bool Init();
   bool Valid() const { return state() != eStateUninited; }
   std::mutex mutex_;
   MQId ssn_id_ = 0;
   std::atomic<State> state_;
   int proc_index_ = -1;

   TopicQueryCache topic_query_cache_;

   class RecvQ
   {
   public:
      void Write(BHMsgHead &&head, std::string &&body) { q_.push_back({std::move(head), std::move(body)}); }
      bool Read(BHMsgHead &head, std::string &body)
      {
         if (q_.empty()) {
            return false;
         } else {
            head = std::move(q_.front().head);
            body = std::move(q_.front().body);
            q_.pop_front();
            return true;
         }
      }

   private:
      struct MsgData {
         BHMsgHead head;
         std::string body;
      };
      std::deque<MsgData> q_;
   };
   Synced<RecvQ> server_buffer_;
   Synced<RecvQ> sub_buffer_;
};

#endif // end of include guard: TOPIC_NODE_YVKWA6TF