From 330f78f3334bcdcdb4cc2ab2dbf66604e0224d71 Mon Sep 17 00:00:00 2001
From: lichao <lichao@aiotlink.com>
Date: 星期五, 21 五月 2021 16:21:45 +0800
Subject: [PATCH] Merge branch 'master' of http://192.168.5.5:10010/r/valib/bhshmq
---
src/topic_node.h | 174 +++++++++++++++++++++++++++++++++++++++------------------
1 files changed, 118 insertions(+), 56 deletions(-)
diff --git a/src/topic_node.h b/src/topic_node.h
index d2cdcf9..c421048 100644
--- a/src/topic_node.h
+++ b/src/topic_node.h
@@ -19,8 +19,11 @@
#define TOPIC_NODE_YVKWA6TF
#include "msg.h"
-#include "socket.h"
+#include "shm_socket.h"
+#include <atomic>
#include <memory>
+#include <mutex>
+#include <vector>
using namespace bhome_shm;
using namespace bhome_msg;
@@ -29,108 +32,167 @@
class TopicNode
{
SharedMemory &shm_;
- MsgRegister info_;
+ ProcInfo info_;
- SharedMemory &shm() { return shm_; }
+ SharedMemory &shm() const { return shm_; }
+ const MQInfo &CenterAddr() const { return BHTopicCenterAddress(shm()); }
+ const MQInfo &BusAddr() const { return BHTopicBusAddress(shm()); }
public:
TopicNode(SharedMemory &shm);
~TopicNode();
- void Start();
- void Stop();
// topic node
- bool Register(ProcInfo &proc, MsgCommonReply &reply_body, const int timeout_ms);
+ bool Register(ProcInfo &proc, MsgCommonReply &reply_body, const int timeout_ms) { return UniRegister(false, proc, reply_body, timeout_ms); }
+ bool UniRegister(const bool internal, 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);
+ 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 &topic, std::string &data, const int timeout_ms);
- bool ServerSendReply(void *src_info, const std::string &data, 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 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);
// publish
- bool Publish(const Topic &topic, const void *data, const size_t size, const int timeout_ms);
+ bool Publish(const MsgPublish &pub, const int timeout_ms);
// subscribe
- typedef std::function<void(const std::string &proc_id, const Topic &topic, const std::string &data)> TopicDataCB;
- bool SubscribeStartWorker(const TopicDataCB &tdcb, int nworker = 2);
- bool Subscribe(MsgTopicList &topics, const int timeout_ms);
- bool RecvSub(std::string &proc_id, Topic &topic, std::string &data, const int timeout_ms);
+ 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 &SockPub() { return SockNode(); }
- auto &SockSub() { return sock_sub_; }
- auto &SockRequest() { return sock_request_; }
- auto &SockClient() { return SockRequest(); }
- auto &SockReply() { return sock_reply_; }
- auto &SockServer() { return SockReply(); }
+ 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_;
- ShmSocket 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
--
Gitblit v1.8.0