submodule/rdsn: fix pegasus compilation failure (apache#194)

Former-commit-id: 416fb98a2f3590c9d3df6119ae7d429d855fcb6d [formerly 5098c9b]
Former-commit-id: 0f298ac5980d7a6354ff39c9b6a588929ddee465

src/client_lib/pegasus_client_factory_impl.cpp

@@ -9,7 +9,7 @@ namespace client {
 
 std::unordered_map<std::string, pegasus_client_factory_impl::app_to_client_map>
     pegasus_client_factory_impl::_cluster_to_clients;
-dsn::service::zlock *pegasus_client_factory_impl::_map_lock;
+dsn::zlock *pegasus_client_factory_impl::_map_lock;
 
 bool pegasus_client_factory_impl::initialize(const char *config_file)
 {
@@ -29,7 +29,7 @@ bool pegasus_client_factory_impl::initialize(const char *config_file)
         }
     }
     pegasus_client_impl::init_error();
-    _map_lock = new ::dsn::service::zlock();
+    _map_lock = new ::dsn::zlock();
     return true;
 }
 
@@ -45,7 +45,7 @@ pegasus_client *pegasus_client_factory_impl::get_client(const char *cluster_name
         return nullptr;
     }
 
-    ::dsn::service::zauto_lock l(*_map_lock);
+    ::dsn::zauto_lock l(*_map_lock);
     auto it = _cluster_to_clients.find(cluster_name);
     if (it == _cluster_to_clients.end()) {
         it = _cluster_to_clients

src/client_lib/pegasus_client_factory_impl.h

@@ -22,7 +22,7 @@ class pegasus_client_factory_impl
     typedef std::unordered_map<std::string, pegasus_client_impl *> app_to_client_map;
     typedef std::unordered_map<std::string, app_to_client_map> cluster_to_app_map;
     static cluster_to_app_map _cluster_to_clients;
-    static ::dsn::service::zlock *_map_lock;
+    static ::dsn::zlock *_map_lock;
 };
 }
 } // namespace

src/client_lib/pegasus_client_impl.h

@@ -7,6 +7,7 @@
 #include <string>
 #include <pegasus/client.h>
 #include <rrdb/rrdb.client.h>
+#include <dsn/tool-api/zlocks.h>
 #include "base/pegasus_key_schema.h"
 #include "base/pegasus_utils.h"
 
@@ -262,7 +263,7 @@ class pegasus_client_impl : public pegasus_client
         int32_t _p;
 
         int64_t _context;
-        mutable ::dsn::service::zlock _lock;
+        mutable ::dsn::zlock _lock;
         std::list<async_scan_next_callback_t> _queue;
         volatile bool _rpc_started;
 

src/client_lib/pegasus_scanner_impl.cpp

@@ -76,7 +76,7 @@ void pegasus_client_impl::pegasus_scanner_impl::async_next(async_scan_next_callb
 
 bool pegasus_client_impl::pegasus_scanner_impl::safe_destructible() const
 {
-    ::dsn::service::zauto_lock l(_lock);
+    ::dsn::zauto_lock l(_lock);
     return _queue.empty();
 }
 
@@ -270,7 +270,7 @@ void pegasus_client_impl::pegasus_scanner_impl::_split_reset()
 
 pegasus_client_impl::pegasus_scanner_impl::~pegasus_scanner_impl()
 {
-    dsn::service::zauto_lock l(_lock);
+    dsn::zauto_lock l(_lock);
 
     dassert(!_rpc_started, "all scan-rpc should be completed here");
     dassert(_queue.empty(), "queue should be empty");

src/redis_protocol/proxy_lib/proxy_layer.cpp

@@ -48,14 +48,14 @@ void proxy_stub::on_rpc_request(dsn::message_ex *request)
     ::dsn::rpc_address source = request->header->from_address;
     std::shared_ptr<proxy_session> ps;
     {
-        ::dsn::service::zauto_read_lock l(_lock);
+        ::dsn::zauto_read_lock l(_lock);
         auto it = _sessions.find(source);
         if (it != _sessions.end()) {
             ps = it->second;
         }
     }
     if (nullptr == ps) {
-        ::dsn::service::zauto_write_lock l(_lock);
+        ::dsn::zauto_write_lock l(_lock);
         auto it = _sessions.find(source);
         if (it != _sessions.end()) {
             ps = it->second;
@@ -79,7 +79,7 @@ void proxy_stub::on_recv_remove_session_request(dsn::message_ex *request)
 
 std::shared_ptr<proxy_session> proxy_stub::remove_session(dsn::rpc_address remote_address)
 {
-    ::dsn::service::zauto_write_lock l(_lock);
+    ::dsn::zauto_write_lock l(_lock);
     auto iter = _sessions.find(remote_address);
     if (iter == _sessions.end()) {
         dwarn("%s has been removed from proxy stub", remote_address.to_string());

src/redis_protocol/proxy_lib/proxy_layer.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <dsn/service_api_cpp.h>
-#include <dsn/cpp/zlocks.h>
+#include <dsn/tool-api/zlocks.h>
 #include <unordered_map>
 #include <functional>
 
@@ -84,7 +84,7 @@ class proxy_stub : public ::dsn::serverlet<proxy_stub>
     void on_rpc_request(dsn::message_ex *request);
     void on_recv_remove_session_request(dsn::message_ex *);
 
-    ::dsn::service::zrwlock_nr _lock;
+    ::dsn::zrwlock_nr _lock;
     std::unordered_map<::dsn::rpc_address, std::shared_ptr<proxy_session>> _sessions;
     proxy_session::factory _factory;
     ::dsn::rpc_address _uri_address;

src/redis_protocol/proxy_lib/redis_parser.cpp

@@ -312,14 +312,14 @@ bool redis_parser::parse(dsn::message_ex *msg)
 
 void redis_parser::enqueue_pending_response(std::unique_ptr<message_entry> &&entry)
 {
-    dsn::service::zauto_lock l(response_lock);
+    dsn::zauto_lock l(response_lock);
     pending_response.emplace_back(std::move(entry));
 }
 
 void redis_parser::fetch_and_dequeue_messages(std::vector<dsn::message_ex *> &msgs,
                                               bool only_ready_ones)
 {
-    dsn::service::zauto_lock l(response_lock);
+    dsn::zauto_lock l(response_lock);
     while (!pending_response.empty()) {
         message_entry *entry = pending_response.front().get();
         dsn::message_ex *r = entry->response.load(std::memory_order_acquire);

src/redis_protocol/proxy_lib/redis_parser.h

@@ -94,7 +94,7 @@ class redis_parser : public proxy_session
 
 private:
     // queue for pipeline the response
-    dsn::service::zlock response_lock;
+    dsn::zlock response_lock;
     std::deque<std::unique_ptr<message_entry>> pending_response;
 
     // recieving message and parsing status

src/server/test/pegasus_server_write_test.cpp

@@ -52,9 +52,6 @@ class pegasus_server_write_test : public pegasus_server_test_base
                     writes[i] = pegasus::create_remove_request(key);
                 }
                 auto cleanup = dsn::defer([=]() {
-                    for (int i = 0; i < total_rpc_cnt; i++) {
-                        writes[i]->release_ref();
-                    }
                     delete[] writes;
                 });