fix center init mutex.

lichao

2021-05-18 cf05ea3d9f43e4e84d621e1f9d54cbef552b6e2b

 src/bh_api.cpp

@@ -1,6 +1,7 @@
#include "bh_api.h"
#include "defs.h"
#include "topic_node.h"
#include <cstdio>
#include <memory>

using namespace bhome_shm;
@@ -8,10 +9,47 @@

namespace
{
std::string GetProcExe()
{
   auto f = fopen("/proc/self/stat", "rb");
   if (f) {
      DEFER1(fclose(f));
      char buf[100] = {0};
      int n = fread(buf, 1, sizeof(buf), f);
      if (n > 0) {
         std::string s(buf, n);
         auto start = s.find('(');
         if (start != std::string::npos) {
            ++start;
            auto end = s.find(')', start);
            return s.substr(start, end - start);
         }
      }
   }
   return std::to_string(getpid());
}
std::unique_ptr<TopicNode> &ProcNodePtr()
{
   static std::mutex mtx;
   std::lock_guard<std::mutex> lk(mtx);

   static std::unique_ptr<TopicNode> ptr;
   if (!ptr && GlobalInit(BHomeShm())) {
      auto InitLog = []() {
         auto id = GetProcExe();
         char path[200] = {0};
         sprintf(path, "/opt/vasystem/valog/bhshmq_node_%s.log", id.c_str());
         ns_log::AddLog(path);
         return true;
      };
      static bool init_log = InitLog();
      ptr.reset(new TopicNode(BHomeShm()));
   }
   return ptr;
}
TopicNode &ProcNode()
{
   static TopicNode node(BHomeShm());
   return node;
   return *ProcNodePtr();
}

class TmpPtr : private boost::noncopyable
@@ -39,11 +77,25 @@
   }
   size_t size() const { return size_; }
   operator bool() const { return ptr_; }
   bool ReleaseTo(void **pdata, int *psize)
   {
      if (!ptr_) {
         return false;
      }
      if (pdata && psize) {
         *psize = size();
         *pdata = release();
      }
      return true;
   }
};

template <class Msg>
bool PackOutput(const Msg &msg, void **out, int *out_len)
{
   if (!out || !out_len) {
      return true; // not wanted.
   }
   auto size = msg.ByteSizeLong();
   TmpPtr p(size);
   if (!p) {
@@ -51,59 +103,105 @@
      return false;
   }
   msg.SerializePartialToArray(p.get(), size);
   *out = p.release();
   *out_len = size;
   p.ReleaseTo(out, out_len);
   return true;
}

template <class MsgIn, class MsgOut = MsgCommonReply>
bool BHApi_In1_Out1(bool (TopicNode::*mfunc)(MsgIn &, MsgOut &, const int),
                    const void *request, const int request_len,
                    void **reply, int *reply_len,
                    const int timeout_ms)
{
   MsgIn input;
   if (!input.ParseFromArray(request, request_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   MsgOut msg_reply;
   auto &ptr = ProcNodePtr();
   if (!ptr) {
      SetLastError(eNotFound, "center not started.");
      return 0;
   }

   return (ProcNode().*mfunc)(input, msg_reply, timeout_ms) &&
          PackOutput(msg_reply, reply, reply_len);
}

template <class MsgIn0, class MsgIn1, class MsgOut = MsgCommonReply>
bool BHApi_In2_Out1(bool (TopicNode::*mfunc)(MsgIn0 &, MsgIn1 &, MsgOut &, const int),
                    const void *in0, const int in0_len,
                    const void *in1, const int in1_len,
                    void **reply, int *reply_len,
                    const int timeout_ms)
{
   MsgIn0 input0;
   MsgIn1 input1;
   if (!input0.ParseFromArray(in0, in0_len) ||
       !input1.ParseFromArray(in1, in1_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   MsgOut msg_reply;
   return (ProcNode().*mfunc)(input0, input1, msg_reply, timeout_ms) &&
          PackOutput(msg_reply, reply, reply_len);
}

} // namespace

bool BHRegister(const void *proc_info,
                const int proc_info_len,
                void **reply,
                int *reply_len,
                const int timeout_ms)
int BHApiIn1Out1Proxy(FBHApiIn1Out1 func,
                      const void *request,
                      const int request_len,
                      void **reply,
                      int *reply_len,
                      const int timeout_ms)
{
   ProcInfo pi;
   if (!pi.ParseFromArray(proc_info, proc_info_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   MsgCommonReply msg_reply;
   if (ProcNode().Register(pi, msg_reply, timeout_ms)) {
      return PackOutput(msg_reply, reply, reply_len);
   } else {
      return false;
   }
   return (*func)(request, request_len, reply, reply_len, timeout_ms);
}

bool BHHeartBeatEasy(const int timeout_ms)
int BHRegister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
   return BHApi_In1_Out1<ProcInfo>(&TopicNode::Register, proc_info, proc_info_len, reply, reply_len, timeout_ms);
}
int BHUnregister(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
   return BHApi_In1_Out1<ProcInfo>(&TopicNode::Unregister, proc_info, proc_info_len, reply, reply_len, timeout_ms);
}

int BHHeartbeatEasy(const int timeout_ms)
{
   return ProcNode().Heartbeat(timeout_ms);
}

bool BHHeartBeat(const void *proc_info,
                 const int proc_info_len,
                 void **reply,
                 int *reply_len,
                 const int timeout_ms)
int BHHeartbeat(const void *proc_info, const int proc_info_len, void **reply, int *reply_len, const int timeout_ms)
{
   ProcInfo pi;
   if (!pi.ParseFromArray(proc_info, proc_info_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   MsgCommonReply msg_reply;
   if (ProcNode().Heartbeat(pi, msg_reply, timeout_ms)) {
      return PackOutput(msg_reply, reply, reply_len);
   } else {
      return false;
   }
   return BHApi_In1_Out1<ProcInfo>(&TopicNode::Heartbeat, proc_info, proc_info_len, reply, reply_len, timeout_ms);
}

bool BHPublish(const void *msgpub,
               const int msgpub_len,
               const int timeout_ms)
int BHRegisterTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
{
   return BHApi_In1_Out1<MsgTopicList>(&TopicNode::ServerRegisterRPC, topics, topics_len, reply, reply_len, timeout_ms);
}

int BHQueryTopicAddress(const void *remote, const int remote_len,
                        const void *topic, const int topic_len,
                        void **reply, int *reply_len,
                        const int timeout_ms)
{
   return BHApi_In2_Out1<BHAddress, MsgQueryTopic, MsgQueryTopicReply>(
       &TopicNode::QueryTopicAddress,
       remote, remote_len, topic, topic_len, reply, reply_len, timeout_ms);
}

int BHSubscribeTopics(const void *topics, const int topics_len, void **reply, int *reply_len, const int timeout_ms)
{
   return BHApi_In1_Out1<MsgTopicList>(&TopicNode::Subscribe, topics, topics_len, reply, reply_len, timeout_ms);
}

int BHPublish(const void *msgpub,
              const int msgpub_len,
              const int timeout_ms)
{
   MsgPublish pub;
   if (!pub.ParseFromArray(msgpub, msgpub_len)) {
@@ -113,11 +211,11 @@
   return ProcNode().Publish(pub, timeout_ms);
}

bool BHReadSub(void **proc_id,
               int *proc_id_len,
               void **msgpub,
               int *msgpub_len,
               const int timeout_ms)
int BHReadSub(void **proc_id,
              int *proc_id_len,
              void **msgpub,
              int *msgpub_len,
              const int timeout_ms)
{
   std::string proc;
   MsgPublish pub;
@@ -125,8 +223,8 @@
   if (ProcNode().RecvSub(proc, pub, timeout_ms)) {
      TmpPtr pproc(proc);
      if (pproc && PackOutput(pub, msgpub, msgpub_len)) {
         *proc_id = pproc.release();
         *proc_id_len = pproc.size();
         pproc.ReleaseTo(proc_id, proc_id_len);
         return true;
      } else {
         SetLastError(ENOMEM, "out of mem");
      }
@@ -134,26 +232,61 @@
   return false;
}

bool BHRequest(const void *request,
               const int request_len,
               void **proc_id,
               int *proc_id_len,
               void **reply,
               int *reply_len,
               const int timeout_ms)
int BHAsyncRequest(const void *remote,
                   const int remote_len,
                   const void *request,
                   const int request_len,
                   void **msg_id,
                   int *msg_id_len)
{
   BHAddress dest;
   MsgRequestTopic req;
   if (!req.ParseFromArray(request, request_len)) {
   if (!dest.ParseFromArray(remote, remote_len) ||
       !req.ParseFromArray(request, request_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   std::string str_msg_id;
   MsgRequestTopicReply out_msg;
   if (ProcNode().ClientAsyncRequest(dest, req, str_msg_id)) {
      if (!msg_id || !msg_id_len) {
         return true;
      }
      TmpPtr ptr(str_msg_id);
      if (ptr) {
         ptr.ReleaseTo(msg_id, msg_id_len);
         return true;
      } else {
         SetLastError(ENOMEM, "out of mem");
      }
   }
   return false;
}

int BHRequest(const void *remote,
              const int remote_len,
              const void *request,
              const int request_len,
              void **proc_id,
              int *proc_id_len,
              void **reply,
              int *reply_len,
              const int timeout_ms)
{
   BHAddress dest;
   MsgRequestTopic req;
   if (!dest.ParseFromArray(remote, remote_len) ||
       !req.ParseFromArray(request, request_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   std::string proc;
   MsgRequestTopicReply out_msg;
   if (ProcNode().ClientSyncRequest(req, proc, out_msg, timeout_ms)) {
   if (ProcNode().ClientSyncRequest(dest, req, proc, out_msg, timeout_ms)) {
      TmpPtr pproc(proc);
      if (pproc && PackOutput(out_msg, reply, reply_len)) {
         *proc_id = pproc.release();
         *proc_id_len = pproc.size();
         pproc.ReleaseTo(proc_id, proc_id_len);
         return true;
      } else {
         SetLastError(ENOMEM, "out of mem");
      }
@@ -161,12 +294,12 @@
   return false;
}

bool BHReadRequest(void **proc_id,
                   int *proc_id_len,
                   void **request,
                   int *request_len,
                   void **src,
                   const int timeout_ms)
int BHReadRequest(void **proc_id,
                  int *proc_id_len,
                  void **request,
                  int *request_len,
                  void **src,
                  const int timeout_ms)
{
   void *src_info = 0;
   std::string proc;
@@ -174,9 +307,9 @@
   if (ProcNode().ServerRecvRequest(src_info, proc, out_msg, timeout_ms)) {
      TmpPtr pproc(proc);
      if (pproc && PackOutput(out_msg, request, request_len)) {
         *proc_id = pproc.release();
         *proc_id_len = pproc.size();
         pproc.ReleaseTo(proc_id, proc_id_len);
         *src = src_info;
         return true;
      } else {
         SetLastError(ENOMEM, "out of mem");
      }
@@ -184,43 +317,27 @@
   return false;
}

bool BHSendReply(void *src,
                 const void *reply,
                 const int reply_len,
                 const int timeout_ms)
int BHSendReply(void *src,
                const void *reply,
                const int reply_len)
{
   MsgRequestTopicReply rep;
   if (!rep.ParseFromArray(reply, reply_len)) {
      SetLastError(eInvalidInput, "invalid input.");
      return false;
   }
   return ProcNode().ServerSendReply(src, rep, timeout_ms);
   return ProcNode().ServerSendReply(src, rep);
}

int BHCleanUp()
void BHStartWorker(FServerCallback server_cb, FSubDataCallback sub_cb, FClientCallback client_cb)
{
   return 0;
}

namespace
{
typedef std::function<bool(const void *, const int)> ServerSender;
} // namespace

void BHStartWorker(FServerCallback server_cb, FSubDataCallback sub_cb)
{
   TopicNode::ServerCB on_req;
   TopicNode::ServerAsyncCB on_req;
   TopicNode::SubDataCB on_sub;
   TopicNode::RequestResultCB on_reply;
   if (server_cb) {
      on_req = [server_cb](const std::string &proc_id, const MsgRequestTopic &request, MsgRequestTopicReply &reply) {
      on_req = [server_cb](void *src, std::string &proc_id, const MsgRequestTopic &request) {
         std::string sreq(request.SerializeAsString());
         bool r = false;
         ServerSender sender = [&](const void *p, const int len) {
            r = reply.ParseFromArray(p, len);
            return r;
         };
         server_cb(proc_id.data(), proc_id.size(), sreq.data(), sreq.size(), (BHServerCallbackTag *) (&sender));
         return r;
         server_cb(proc_id.data(), proc_id.size(), sreq.data(), sreq.size(), src);
      };
   }
   if (sub_cb) {
@@ -229,20 +346,27 @@
         sub_cb(proc_id.data(), proc_id.size(), s.data(), s.size());
      };
   }
   if (client_cb) {
      on_reply = [client_cb](const BHMsgHead &head, const MsgRequestTopicReply &rep) {
         std::string s(rep.SerializeAsString());
         client_cb(head.proc_id().data(), head.proc_id().size(),
                   head.msg_id().data(), head.msg_id().size(),
                   s.data(), s.size());
      };
   }

   ProcNode().Start(on_req, on_sub);
}
bool BHServerCallbackReply(const BHServerCallbackTag *tag,
                           const void *data,
                           const int data_len)
{
   auto &sender = *(const ServerSender *) (tag);
   return sender(data, data_len);
   ProcNode().Start(on_req, on_sub, on_reply);
}

void BHFree(void *data, int size)
{
   free(data);
}

int BHCleanup()
{
   ProcNodePtr().reset();
   return 0;
}

int BHGetLastError(void **msg, int *msg_len)
@@ -252,10 +376,7 @@
      std::string err_msg;
      GetLastError(ec, err_msg);
      TmpPtr p(err_msg);
      if (p) {
         *msg = p.release();
         *msg_len = p.size();
      }
      p.ReleaseTo(msg, msg_len);
   }
   return ec;
}