!43 feat(jsonrpc): 添加Rpc::clear()方法，用于清除缓存数据

Author: hevake

modules/eventx/timeout_monitor.hpp

@@ -57,6 +57,7 @@ class TimeoutMonitor {
     void setCallback(const Callback &cb) { cb_ = cb; }
 
     void add(const T &value);
+    void clear();
 
     void cleanup();
 

modules/eventx/timeout_monitor_impl.hpp

@@ -73,15 +73,31 @@ void TimeoutMonitor<T>::add(const T &value)
     ++value_number_;
 }
 
+template <typename T>
+void TimeoutMonitor<T>::clear()
+{
+    if (value_number_ > 0) {
+        value_number_ = 0;
+        sp_timer_->disable();
+
+        PollItem *item = curr_item_;
+        do {
+            item->items.clear();
+            item = item->next;
+        } while (item != curr_item_);
+    }
+}
+
 template <typename T>
 void TimeoutMonitor<T>::cleanup()
 {
     if (curr_item_ == nullptr)
         return;
 
-    if (value_number_ > 0)
+    if (value_number_ > 0) {
         sp_timer_->disable();
-    value_number_ = 0;
+        value_number_ = 0;
+    }
 
     PollItem *item = curr_item_->next;
     curr_item_->next = nullptr;

modules/eventx/timeout_monitor_test.cpp

@@ -55,6 +55,39 @@ TEST(TimeoutMonitor, Basic)
     EXPECT_TRUE(run);
 }
 
+//! 测试中途clear()的操作，观察有没有被误触发
+TEST(TimeoutMonitor, Clear)
+{
+    auto sp_loop = Loop::New();
+    auto sp_timer = sp_loop->newTimerEvent();
+    SetScopeExitAction(
+      [=] {
+        delete sp_loop;
+        delete sp_timer;
+      }
+    );
+    sp_timer->initialize(std::chrono::milliseconds(25), Event::Mode::kOneshot);
+
+    TimeoutMonitor<int> tm(sp_loop);
+    tm.initialize(milliseconds(10), 3);
+
+    sp_timer->setCallback([&] { tm.clear(); });
+    sp_timer->enable();
+
+    bool run = false;
+    tm.setCallback([&] (int value) {
+        run = true;
+    });
+
+    tm.add(100);
+    tm.add(101);
+
+    sp_loop->exitLoop(milliseconds(120));
+    sp_loop->runLoop();
+
+    EXPECT_FALSE(run);
+}
+
 }
 }
 }

modules/jsonrpc/proto.h

@@ -36,6 +36,8 @@ class Proto {
     using RecvRespondStrCallback = std::function<void(const std::string &id, const Response &response)>;
     using SendDataCallback = std::function<void(const void* data_ptr, size_t data_size)>;
 
+    virtual ~Proto() {}
+
     void setRecvCallback(RecvRequestIntCallback &&req_cb, RecvRespondIntCallback &&rsp_cb);
     void setRecvCallback(RecvRequestStrCallback &&req_cb, RecvRespondStrCallback &&rsp_cb);
     void setSendCallback(SendDataCallback &&cb);

modules/jsonrpc/rpc.cpp

@@ -199,6 +199,17 @@ void Rpc::setStrIdGenFunc(StrIdGenFunc &&func)
     }
 }
 
+void Rpc::clear()
+{
+    int_id_alloc_ = 0;
+    request_callback_.clear();
+    tobe_respond_.clear();
+    request_timeout_.clear();
+    respond_timeout_.clear();
+    int_to_str_map_.clear();
+    str_to_int_map_.clear();
+}
+
 void Rpc::onRecvRequestInt(int int_id, const std::string &method, const Json &js_params)
 {
     RECORD_SCOPE();

modules/jsonrpc/rpc.h

@@ -89,6 +89,9 @@ class Rpc {
     //! 设置string id生成函数，默认为UUIDv4
     void setStrIdGenFunc(StrIdGenFunc &&func);
 
+    //! 清除缓存数据，恢复到没有收发数据之前的状态
+    void clear();
+
   protected:
     void onRecvRequestInt(int int_id, const std::string &method, const Json &params);
     void onRecvRespondInt(int int_id, const Response &response);

modules/jsonrpc/rpc_int_test.cpp

@@ -205,5 +205,41 @@ TEST(RpcInt, RequestTimeout) {
     EXPECT_TRUE(is_method_cb_invoke);
 }
 
+//! 发了一个请求，在回复之前被clear
+TEST(RpcInt, Clear) {
+    auto loop = event::Loop::New();
+    auto timer = loop->newTimerEvent();
+    SetScopeExitAction(
+      [=] {
+        delete loop;
+        delete timer;
+      }
+    );
+
+    timer->initialize(std::chrono::milliseconds(50), event::Event::Mode::kOneshot);
+
+    Rpc rpc(loop);
+    RawStreamProto proto;
+    rpc.initialize(&proto, 1);
+
+    timer->setCallback([&] { rpc.clear(); });
+    timer->enable();
+
+    bool is_method_cb_invoke = false;
+    loop->run(
+        [&] {
+            rpc.request("A", Json(),
+                [&] (const Response &r) {
+                    is_method_cb_invoke = true;
+                }
+            );
+        }
+    );
+    loop->exitLoop(std::chrono::milliseconds(1001));
+    loop->runLoop();
+
+    EXPECT_FALSE(is_method_cb_invoke);
+}
+
 }
 }