From 420975beb0fa25730200f037bf16e9d60254eb8a Mon Sep 17 00:00:00 2001
From: yvxiang <yangce@baidu.com>
Date: Mon, 24 Oct 2016 17:27:26 +0800
Subject: [PATCH 1/4] Add membership variable

---
 src/nameserver/block_mapping.cc         | 14 ++++++++++++--
 src/nameserver/block_mapping.h          |  4 ++++
 src/nameserver/block_mapping_manager.cc |  6 ++++++
 src/nameserver/block_mapping_manager.h  |  1 +
 src/nameserver/nameserver_impl.cc       | 22 +++++++++++++++++++---
 src/nameserver/nameserver_impl.h        |  7 ++++++-
 6 files changed, 48 insertions(+), 6 deletions(-)

diff --git a/src/nameserver/block_mapping.cc b/src/nameserver/block_mapping.cc
index 325d9a8f..6df54d1c 100644
--- a/src/nameserver/block_mapping.cc
+++ b/src/nameserver/block_mapping.cc
@@ -35,7 +35,7 @@ NSBlock::NSBlock(int64_t block_id, int32_t replica,
       recover_stat(block_version < 0 ? kBlockWriting : kNotInRecover) {
 }
 
-BlockMapping::BlockMapping(ThreadPool* thread_pool) : thread_pool_(thread_pool) {}
+BlockMapping::BlockMapping(ThreadPool* thread_pool) : thread_pool_(thread_pool), clean_redundancy_(false) {}
 
 bool BlockMapping::GetBlock(int64_t block_id, NSBlock* block) {
     MutexLock lock(&mu_, "BlockMapping::GetBlock", 1000);
@@ -265,7 +265,7 @@ bool BlockMapping::UpdateNormalBlock(NSBlock* nsblock,
     }
 
     TryRecover(nsblock);
-    if (FLAGS_clean_redundancy && replica.size() > nsblock->expect_replica_num) {
+    if (clean_redundancy_ && replica.size() > nsblock->expect_replica_num) {
         LOG(INFO, "Too much replica #%ld R%lu expect=%d C%d ",
             block_id, replica.size(), nsblock->expect_replica_num, cs_id);
         replica.erase(cs_id);
@@ -948,5 +948,15 @@ void BlockMapping::MarkIncomplete(int64_t block_id) {
     }
 }
 
+void BlockMapping::SetCleanRedundancy(bool clean) {
+    MutexLock lock(&mu_);
+    clean_redundancy_ = clean;
+}
+
+bool BlockMapping::GetCleanRedundancyState() {
+    mu_.AssertHeld();
+    return clean_redundancy_;
+}
+
 } // namespace bfs
 } // namespace baidu
diff --git a/src/nameserver/block_mapping.h b/src/nameserver/block_mapping.h
index 692d5ab1..789e705f 100644
--- a/src/nameserver/block_mapping.h
+++ b/src/nameserver/block_mapping.h
@@ -80,6 +80,7 @@ class BlockMapping {
     void ListRecover(RecoverBlockSet* blocks);
     int32_t GetCheckNum();
     void MarkIncomplete(int64_t block_id);
+    void SetCleanRedundancy(bool clean);
 private:
     void DealWithDeadBlockInternal(int32_t cs_id, int64_t block_id);
     typedef std::map<int32_t, std::set<int64_t> > CheckList;
@@ -100,6 +101,7 @@ class BlockMapping {
                            int64_t block_version);
     bool UpdateIncompleteBlock(NSBlock* nsblock,int32_t cs_id, int64_t block_size,
                                int64_t block_version);
+    bool GetCleanRedundancyState();
 private:
     Mutex mu_;
     ThreadPool* thread_pool_;
@@ -112,6 +114,8 @@ class BlockMapping {
     std::set<int64_t> lo_pri_recover_;
     std::set<int64_t> hi_pri_recover_;
     std::set<int64_t> lost_blocks_;
+
+    volatile bool clean_redundancy_;
 };
 
 } // namespace bfs
diff --git a/src/nameserver/block_mapping_manager.cc b/src/nameserver/block_mapping_manager.cc
index ae401d1a..8be5a67f 100644
--- a/src/nameserver/block_mapping_manager.cc
+++ b/src/nameserver/block_mapping_manager.cc
@@ -154,5 +154,11 @@ void BlockMappingManager::MarkIncomplete(int64_t block_id) {
     block_mapping_[bucket_offset]->MarkIncomplete(block_id);
 }
 
+void BlockMappingManager::SetCleanRedundancy(bool clean) {
+    for (size_t i = 0; i < block_mapping_.size(); i++) {
+        block_mapping_[i]->SetCleanRedundancy(clean);
+    }
+}
+
 } //namespace bfs
 } //namespace baidu
diff --git a/src/nameserver/block_mapping_manager.h b/src/nameserver/block_mapping_manager.h
index e2c14d66..b2a1fbb6 100644
--- a/src/nameserver/block_mapping_manager.h
+++ b/src/nameserver/block_mapping_manager.h
@@ -39,6 +39,7 @@ public :
     void GetRecoverNum(int32_t bucket_id, RecoverBlockNum* recover_num);
     void ListRecover(RecoverBlockSet* recover_blocks);
     void MarkIncomplete(int64_t block_id);
+    void SetCleanRedundancy(bool clean);
 private:
     int32_t GetBucketOffset(int64_t block_id);
 private:
diff --git a/src/nameserver/nameserver_impl.cc b/src/nameserver/nameserver_impl.cc
index 33e641d4..090ee07e 100644
--- a/src/nameserver/nameserver_impl.cc
+++ b/src/nameserver/nameserver_impl.cc
@@ -55,6 +55,7 @@ extern common::Counter g_blocks_num;
 
 NameServerImpl::NameServerImpl(Sync* sync) : readonly_(true),
     recover_timeout_(FLAGS_nameserver_start_recover_timeout),
+    block_report_timeout_(FLAGS_block_report_timeout),
     recover_mode_(kStopRecover), sync_(sync) {
     block_mapping_manager_ = new BlockMappingManager(FLAGS_blockmapping_bucket_num);
     report_thread_pool_ = new common::ThreadPool(FLAGS_nameserver_report_thread_num);
@@ -1106,13 +1107,13 @@ bool NameServerImpl::WebService(const sofa::pbrpc::HTTPRequest& request,
                     response.content->Append("<h1>Bad Parameter : 2 <= block_report_timeout <= 3600 </h1>");
                     return true;
                 }
-                FLAGS_block_report_timeout = v;
+                SetBlockReportTimeout(v);
             } else if (it->first == "clean_redundancy") {
                 if (it->second != "true" && it->second != "false") {
                     response.content->Append("<h1>Bad Parameter : clean_redundancy == true || false");
                     return true;
                 }
-                FLAGS_clean_redundancy = it->second == "true" ? true : false;
+                SetCleanRedundancy(it->second == "true" ? true : false);
             } else {
                 response.content->Append("<h1>Bad Parameter :");
                 response.content->Append(it->first);
@@ -1348,7 +1349,8 @@ static void CallMethodHelper(NameServerImpl* impl,
                              int64_t recv_time) {
     if (method->index() == 16) {
         int64_t delay = common::timer::get_micros() - recv_time;
-        if (delay > FLAGS_block_report_timeout *1000L * 1000L) {
+        int32_t timeout = impl->GetBlockReportTimeout();
+        if (delay > timeout * 1000L * 1000L) {
             const BlockReportRequest* report =
                 static_cast<const BlockReportRequest*>(request);
             LOG(WARNING, "BlockReport from %s, delay %ld ms",
@@ -1407,6 +1409,20 @@ void NameServerImpl::CallMethod(const ::google::protobuf::MethodDescriptor* meth
     }
 }
 
+void NameServerImpl::SetBlockReportTimeout(int32_t v) {
+    MutexLock lock(&mu_);
+    block_report_timeout_ = v;
+}
+
+void NameServerImpl::SetCleanRedundancy(bool clean) {
+    block_mapping_manager_->SetCleanRedundancy(clean);
+}
+
+int32_t NameServerImpl::GetBlockReportTimeout() {
+    MutexLock lock(&mu_);
+    return block_report_timeout_;
+}
+
 } // namespace bfs
 } // namespace baidu
 
diff --git a/src/nameserver/nameserver_impl.h b/src/nameserver/nameserver_impl.h
index d87d1bf5..7b9840ae 100644
--- a/src/nameserver/nameserver_impl.h
+++ b/src/nameserver/nameserver_impl.h
@@ -125,6 +125,7 @@ class NameServerImpl : public NameServer {
             ::google::protobuf::Closure* done);
 
     bool WebService(const sofa::pbrpc::HTTPRequest&, sofa::pbrpc::HTTPResponse&);
+    int32_t GetBlockReportTimeout();
 
 private:
     void CheckLeader();
@@ -152,6 +153,8 @@ class NameServerImpl : public NameServer {
     bool CheckFileHasBlock(const FileInfo& file_info,
                            const std::string& file_name,
                            int64_t block_id);
+    void SetBlockReportTimeout(int32_t v);
+    void SetCleanRedundancy(bool clean);
 private:
     /// Global thread pool
     ThreadPool* read_thread_pool_;
@@ -164,7 +167,8 @@ class NameServerImpl : public NameServer {
     BlockMappingManager* block_mapping_manager_;
 
     volatile bool readonly_;
-    volatile int recover_timeout_;
+    volatile int32_t recover_timeout_;
+    int32_t block_report_timeout_;
     RecoverMode recover_mode_;
     int64_t start_time_;
     /// Namespace
@@ -172,6 +176,7 @@ class NameServerImpl : public NameServer {
     /// ha
     Sync* sync_;
     bool is_leader_;
+    Mutex mu_;
 };
 
 } // namespace bfs

From f266e1e43a806fa1bd31611a64138a11b6d7f691 Mon Sep 17 00:00:00 2001
From: yvxiang <yangce@baidu.com>
Date: Mon, 24 Oct 2016 17:30:33 +0800
Subject: [PATCH 2/4] Remove volatile

---
 src/nameserver/block_mapping.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nameserver/block_mapping.h b/src/nameserver/block_mapping.h
index 789e705f..3bcbd51b 100644
--- a/src/nameserver/block_mapping.h
+++ b/src/nameserver/block_mapping.h
@@ -115,7 +115,7 @@ class BlockMapping {
     std::set<int64_t> hi_pri_recover_;
     std::set<int64_t> lost_blocks_;
 
-    volatile bool clean_redundancy_;
+    bool clean_redundancy_;
 };
 
 } // namespace bfs

From bf53f5ca66c744f613731922b4a7dd16d1efc5a4 Mon Sep 17 00:00:00 2001
From: yvxiang <yangce@baidu.com>
Date: Tue, 25 Oct 2016 11:30:23 +0800
Subject: [PATCH 3/4] Use NameSerfverParams

---
 src/chunkserver/chunkserver_impl.h    |  2 +-
 src/nameserver/chunkserver_manager.cc |  2 +-
 src/nameserver/chunkserver_manager.h  |  4 +-
 src/nameserver/nameserver_impl.cc     | 58 +++++++++++++++++++--------
 src/nameserver/nameserver_impl.h      | 21 ++--------
 src/proto/status_code.proto           | 23 ++++++++++-
 6 files changed, 72 insertions(+), 38 deletions(-)

diff --git a/src/chunkserver/chunkserver_impl.h b/src/chunkserver/chunkserver_impl.h
index ca8a9a98..7ab9b6b3 100644
--- a/src/chunkserver/chunkserver_impl.h
+++ b/src/chunkserver/chunkserver_impl.h
@@ -96,7 +96,7 @@ class ChunkServerImpl : public ChunkServer {
     int64_t report_id_;
     volatile bool service_stop_;
 
-    Params params_;
+    ChunkServerParams params_;
 };
 
 } // namespace bfs
diff --git a/src/nameserver/chunkserver_manager.cc b/src/nameserver/chunkserver_manager.cc
index 279a22aa..253847db 100644
--- a/src/nameserver/chunkserver_manager.cc
+++ b/src/nameserver/chunkserver_manager.cc
@@ -557,7 +557,7 @@ void ChunkServerManager::AddBlock(int32_t id, int64_t block_id, bool is_recover)
     cs_block_map->blocks.insert(block_id);
 }
 
-void ChunkServerManager::SetParam(const Params& p) {
+void ChunkServerManager::SetParam(const ChunkServerParams& p) {
     MutexLock lock(&mu_);
     if (p.report_interval() != -1) {
         params_.set_report_interval(p.report_interval());
diff --git a/src/nameserver/chunkserver_manager.h b/src/nameserver/chunkserver_manager.h
index 36014b7d..e68bbb88 100644
--- a/src/nameserver/chunkserver_manager.h
+++ b/src/nameserver/chunkserver_manager.h
@@ -52,7 +52,7 @@ class ChunkServerManager {
     bool GetShutdownChunkServerStat();
     int64_t AddBlockWithCheck(int32_t id, const std::set<int64_t>& blocks, int64_t start, int64_t end,
                   std::vector<int64_t>* lost, int64_t report_id);
-    void SetParam(const Params& p);
+    void SetParam(const ChunkServerParams& p);
 private:
     struct ChunkServerBlockMap {
         Mutex* mu;
@@ -96,7 +96,7 @@ class ChunkServerManager {
     std::vector<std::string> chunkservers_to_offline_;
 
     // for chunkserver
-    Params params_;
+    ChunkServerParams params_;
 };
 
 
diff --git a/src/nameserver/nameserver_impl.cc b/src/nameserver/nameserver_impl.cc
index 090ee07e..aea94937 100644
--- a/src/nameserver/nameserver_impl.cc
+++ b/src/nameserver/nameserver_impl.cc
@@ -1024,21 +1024,28 @@ bool NameServerImpl::WebService(const sofa::pbrpc::HTTPRequest& request,
         ListRecover(&response);
         return true;
     } else if (path == "/dfs/hi_only") {
-        recover_timeout_ = 0;
+        NameServerParams para;
+        para.set_recover_timeout(0);
         LOG(INFO, "ChangeRecoverMode hi_only");
         recover_mode_ = kHiOnly;
+        para.set_recover_mode(kHiOnly);
         response.content->Append("<body onload=\"history.back()\"></body>");
+        SetNameServerParams(para);
         return true;
     } else if (path == "/dfs/recover_all") {
-        recover_timeout_ = 0;
+        NameServerParams para;
+        para.set_recover_timeout(0);
         LOG(INFO, "ChangeRecoverMode recover_all");
-        recover_mode_ = kRecoverAll;
+        para.set_recover_mode(kRecoverAll);
+        SetNameServerParams(para);
         response.content->Append("<body onload=\"history.back()\"></body>");
         return true;
     } else if (path == "/dfs/stop_recover") {
-        recover_timeout_ = 0;
+        NameServerParams para;
+        para.set_recover_timeout(0);
         LOG(INFO, "ChangeRecoverMode stop_recover");
-        recover_mode_ = kStopRecover;
+        para.set_recover_mode(kStopRecover);
+        SetNameServerParams(para);
         response.content->Append("<body onload=\"history.back()\"></body>");
         return true;
     } else if (path == "/dfs/leave_read_only") {
@@ -1048,7 +1055,9 @@ bool NameServerImpl::WebService(const sofa::pbrpc::HTTPRequest& request,
         return true;
     } else if (path == "/dfs/entry_read_only") {
         LOG(INFO, "ChangeStatus entry_read_only");
-        readonly_ = true;
+        NameServerParams para;
+        para.set_readonly(true);
+        SetNameServerParams(para);
         response.content->Append("<body onload=\"history.back()\"></body>");
         return true;
     } else if (path == "/dfs/kick" && FLAGS_bfs_web_kick_enable) {
@@ -1072,7 +1081,7 @@ bool NameServerImpl::WebService(const sofa::pbrpc::HTTPRequest& request,
         display_mode = kOverload;
     } else if (path == "/dfs/set") {
         std::map<const std::string, std::string>::const_iterator it = request.query_params->begin();
-        Params p;
+        ChunkServerParams p;
         if (it != request.query_params->end()) {
             int32_t v = 0;
             if (it->first != "clean_redundancy") {
@@ -1107,13 +1116,21 @@ bool NameServerImpl::WebService(const sofa::pbrpc::HTTPRequest& request,
                     response.content->Append("<h1>Bad Parameter : 2 <= block_report_timeout <= 3600 </h1>");
                     return true;
                 }
-                SetBlockReportTimeout(v);
+                NameServerParams para;
+                para.set_block_report_timeout(v);
+                SetNameServerParams(para);
             } else if (it->first == "clean_redundancy") {
                 if (it->second != "true" && it->second != "false") {
                     response.content->Append("<h1>Bad Parameter : clean_redundancy == true || false");
                     return true;
                 }
-                SetCleanRedundancy(it->second == "true" ? true : false);
+                NameServerParams para;
+                if (it->second == "true") {
+                    para.set_clean_redundancy(true);
+                } else {
+                    para.set_clean_redundancy(false);
+                }
+                SetNameServerParams(para);
             } else {
                 response.content->Append("<h1>Bad Parameter :");
                 response.content->Append(it->first);
@@ -1409,17 +1426,26 @@ void NameServerImpl::CallMethod(const ::google::protobuf::MethodDescriptor* meth
     }
 }
 
-void NameServerImpl::SetBlockReportTimeout(int32_t v) {
+void NameServerImpl::SetNameServerParams(const NameServerParams& para) {
     MutexLock lock(&mu_);
-    block_report_timeout_ = v;
-}
-
-void NameServerImpl::SetCleanRedundancy(bool clean) {
-    block_mapping_manager_->SetCleanRedundancy(clean);
+    if (para.has_block_report_timeout()) {
+        block_report_timeout_ = para.block_report_timeout();
+    }
+    if (para.has_clean_redundancy()) {
+        block_mapping_manager_->SetCleanRedundancy(para.clean_redundancy());
+    }
+    if (para.has_recover_mode()) {
+        recover_mode_ = para.recover_mode();
+    }
+    if (para.has_recover_timeout()) {
+        recover_timeout_ = para.recover_timeout();
+    }
+    if (para.has_readonly()) {
+        readonly_ = para.readonly();
+    }
 }
 
 int32_t NameServerImpl::GetBlockReportTimeout() {
-    MutexLock lock(&mu_);
     return block_report_timeout_;
 }
 
diff --git a/src/nameserver/nameserver_impl.h b/src/nameserver/nameserver_impl.h
index 7b9840ae..3466879b 100644
--- a/src/nameserver/nameserver_impl.h
+++ b/src/nameserver/nameserver_impl.h
@@ -10,6 +10,7 @@
 #include <common/thread_pool.h>
 
 #include "proto/nameserver.pb.h"
+#include "proto/status_code.pb.h"
 
 namespace sofa {
 namespace pbrpc {
@@ -26,19 +27,6 @@ class ChunkServerManager;
 class BlockMappingManager;
 class Sync;
 
-enum RecoverMode {
-    kStopRecover = 0,
-    kHiOnly = 1,
-    kRecoverAll = 2,
-};
-
-enum DisplayMode {
-    kDisplayAll = 0,
-    kAliveOnly = 1,
-    kDeadOnly = 2,
-    kOverload = 3,
-};
-
 class NameServerImpl : public NameServer {
 public:
     NameServerImpl(Sync* sync);
@@ -153,8 +141,7 @@ class NameServerImpl : public NameServer {
     bool CheckFileHasBlock(const FileInfo& file_info,
                            const std::string& file_name,
                            int64_t block_id);
-    void SetBlockReportTimeout(int32_t v);
-    void SetCleanRedundancy(bool clean);
+    void SetNameServerParams(const NameServerParams& para);
 private:
     /// Global thread pool
     ThreadPool* read_thread_pool_;
@@ -168,8 +155,8 @@ class NameServerImpl : public NameServer {
 
     volatile bool readonly_;
     volatile int32_t recover_timeout_;
-    int32_t block_report_timeout_;
-    RecoverMode recover_mode_;
+    volatile int32_t block_report_timeout_;
+    volatile RecoverMode recover_mode_;
     int64_t start_time_;
     /// Namespace
     NameSpace* namespace_;
diff --git a/src/proto/status_code.proto b/src/proto/status_code.proto
index 1577fda8..a68f3611 100644
--- a/src/proto/status_code.proto
+++ b/src/proto/status_code.proto
@@ -62,9 +62,30 @@ enum RecoverPri {
     kLow = 1;
 }
 
-message Params {
+enum RecoverMode {
+    kStopRecover = 0;
+    kHiOnly = 1;
+    kRecoverAll = 2;
+}
+
+enum DisplayMode {
+    kDisplayAll = 0;
+    kAliveOnly = 1;
+    kDeadOnly = 2;
+    kOverload = 3;
+}
+
+message ChunkServerParams {
     optional int32 report_interval = 1 [default = -1];
     optional int32 report_size = 2 [default = -1];
     optional int32 recover_size = 3 [default = -1];
     optional int32 keepalive_timeout = 4 [default = -1];
 }
+
+message NameServerParams {
+    optional int32 block_report_timeout = 1;
+    optional bool clean_redundancy = 2;
+    optional RecoverMode recover_mode = 3;
+    optional int32 recover_timeout = 4;
+    optional bool readonly = 5;
+}

From ee907f0ef75b68bd5cfcd296bcda0337d0df6161 Mon Sep 17 00:00:00 2001
From: yvxiang <yangce@baidu.com>
Date: Tue, 25 Oct 2016 14:52:48 +0800
Subject: [PATCH 4/4] Remove useless code

---
 src/nameserver/block_mapping.cc | 5 -----
 src/nameserver/block_mapping.h  | 1 -
 2 files changed, 6 deletions(-)

diff --git a/src/nameserver/block_mapping.cc b/src/nameserver/block_mapping.cc
index 6df54d1c..088c5618 100644
--- a/src/nameserver/block_mapping.cc
+++ b/src/nameserver/block_mapping.cc
@@ -953,10 +953,5 @@ void BlockMapping::SetCleanRedundancy(bool clean) {
     clean_redundancy_ = clean;
 }
 
-bool BlockMapping::GetCleanRedundancyState() {
-    mu_.AssertHeld();
-    return clean_redundancy_;
-}
-
 } // namespace bfs
 } // namespace baidu
diff --git a/src/nameserver/block_mapping.h b/src/nameserver/block_mapping.h
index 3bcbd51b..a1aaabc5 100644
--- a/src/nameserver/block_mapping.h
+++ b/src/nameserver/block_mapping.h
@@ -101,7 +101,6 @@ class BlockMapping {
                            int64_t block_version);
     bool UpdateIncompleteBlock(NSBlock* nsblock,int32_t cs_id, int64_t block_size,
                                int64_t block_version);
-    bool GetCleanRedundancyState();
 private:
     Mutex mu_;
     ThreadPool* thread_pool_;