Feature: When the cluster capacity is almost full, make the cluster read only

Signed-off-by: liuminjian <[email protected]>

Author: liuminjian

conf/chunkserver.conf

@@ -128,6 +128,8 @@ copyset.sync_chunk_limits=2097152
 copyset.sync_threshold=65536
 # check syncing interval
 copyset.check_syncing_interval_ms=500
+# wait for retry time when disk space is insufficient
+copyset.wait_for_disk_freed_interval_ms=60000
 
 #
 # Clone settings
@@ -215,6 +217,8 @@ chunkfilepool.allocate_percent=80
 chunkfilepool.chunk_file_pool_size=1GB
 # The thread num for format chunks
 chunkfilepool.thread_num=1
+# 当chunkserver磁盘使用率超过百分比，heartbeat设置disk状态
+chunkfilepool.diskUsagePercentLimit=95
 
 #
 # WAL file pool

proto/chunk.proto

@@ -85,6 +85,7 @@ enum CHUNK_OP_STATUS {
     CHUNK_OP_STATUS_BACKWARD = 10;          // 请求的版本落后当前chunk的版本
     CHUNK_OP_STATUS_CHUNK_EXIST = 11;       // chunk已存在
     CHUNK_OP_STATUS_EPOCH_TOO_OLD = 12;     // request epoch too old
+    CHUNK_OP_STATUS_READONLY = 13;          // If there is insufficient disk space, set the chunkserver to read-only
 };
 
 message ChunkResponse {

proto/heartbeat.proto

@@ -71,8 +71,13 @@ message CopysetStatistics {
     required uint32 writeIOPS = 4;
 }
 
+enum ErrorType {
+    NORMAL = 0;
+    DISKFULL = 1;
+}
+
 message DiskState {
-    required uint32 errType = 1;
+    required ErrorType errType = 1;
     required string errMsg = 2;
 }
 

proto/topology.proto

@@ -48,6 +48,7 @@ enum ChunkServerStatus {
 enum DiskState {
     DISKNORMAL = 0;
     DISKERROR = 1;
+    DISKFULL = 2;
 }
 
 enum OnlineState {

src/chunkserver/chunkserver.cpp

@@ -710,6 +710,9 @@ void ChunkServer::InitCopysetNodeOptions(
         LOG_IF(FATAL, !conf->GetUInt32Value("copyset.sync_trigger_seconds",
                 &copysetNodeOptions->syncTriggerSeconds));
     }
+    LOG_IF(FATAL, !conf->GetUInt32Value(
+            "copyset.wait_for_disk_freed_interval_ms",
+            &copysetNodeOptions->waitForDiskFreedIntervalMs));
 }
 
 void ChunkServer::InitCopyerOptions(
@@ -781,6 +784,8 @@ void ChunkServer::InitHeartbeatOptions(
         &heartbeatOptions->intervalSec));
     LOG_IF(FATAL, !conf->GetUInt32Value("mds.heartbeat_timeout",
         &heartbeatOptions->timeout));
+    LOG_IF(FATAL, !conf->GetUInt32Value("chunkfilepool.diskUsagePercentLimit",
+        &heartbeatOptions->chunkserverDiskLimit));
 }
 
 void ChunkServer::InitRegisterOptions(

src/chunkserver/config_info.h

@@ -140,6 +140,8 @@ struct CopysetNodeOptions {
     uint64_t syncThreshold = 64 * 1024;
     // check syncing interval
     uint32_t checkSyncingIntervalMs = 500u;
+    // wait for retry time when disk space is insufficient
+    uint32_t waitForDiskFreedIntervalMs = 60000;
 
     CopysetNodeOptions();
 };

src/chunkserver/copyset_node.cpp

@@ -85,7 +85,8 @@ CopysetNode::CopysetNode(const LogicPoolID &logicPoolId,
     lastScanSec_(0),
     enableOdsyncWhenOpenChunkFile_(false),
     isSyncing_(false),
-    checkSyncingIntervalMs_(500) {
+    checkSyncingIntervalMs_(500),
+    readOnly_(false) {
 }
 
 CopysetNode::~CopysetNode() {
@@ -135,6 +136,8 @@ int CopysetNode::Init(const CopysetNodeOptions &options) {
     dsOptions.locationLimit = options.locationLimit;
     dsOptions.enableOdsyncWhenOpenChunkFile =
         options.enableOdsyncWhenOpenChunkFile;
+    dsOptions.waitForDiskFreedIntervalMs =
+            options.waitForDiskFreedIntervalMs;
     dataStore_ = std::make_shared<CSDataStore>(options.localFileSystem,
                                                options.chunkFilePool,
                                                dsOptions);
@@ -345,6 +348,14 @@ void CopysetNode::WaitSnapshotDone() {
     }
 }
 
+bool CopysetNode::ReadOnly() const {
+    return readOnly_.load(std::memory_order_acquire);
+}
+
+void CopysetNode::SetReadOnly(bool readOnly) {
+    readOnly_.store(readOnly, std::memory_order_release);
+}
+
 void CopysetNode::save_snapshot_background(::braft::SnapshotWriter *writer,
                                    ::braft::Closure *done) {
     brpc::ClosureGuard doneGuard(done);

src/chunkserver/copyset_node.h

@@ -469,6 +469,10 @@ class CopysetNode : public braft::StateMachine,
 
     void WaitSnapshotDone();
 
+    bool ReadOnly() const;
+
+    void SetReadOnly(bool readOnly);
+
  private:
     inline std::string GroupId() {
         return ToGroupId(logicPoolId_, copysetId_);
@@ -545,6 +549,8 @@ class CopysetNode : public braft::StateMachine,
     uint32_t checkSyncingIntervalMs_;
     // async snapshot future object
     std::future<void> snapshotFuture_;
+    // copyset readonly flag
+    std::atomic<bool> readOnly_;
 };
 
 }  // namespace chunkserver

src/chunkserver/datastore/chunkserver_chunkfile.cpp

@@ -22,6 +22,7 @@
 #include <fcntl.h>
 #include <algorithm>
 #include <memory>
+#include <errno.h>
 
 #include "src/chunkserver/datastore/chunkserver_datastore.h"
 #include "src/chunkserver/datastore/chunkserver_chunkfile.h"
@@ -207,7 +208,7 @@ CSErrorCode CSChunkFile::Open(bool createFile) {
         if (rc != 0  && rc != -EEXIST) {
             LOG(ERROR) << "Error occured when create file."
                        << " filepath = " << chunkFilePath;
-            return CSErrorCode::InternalError;
+            return rc == -ENOSPC ? CSErrorCode::NoSpaceError : CSErrorCode::InternalError;
         }
     }
     int rc = -1;
@@ -400,7 +401,7 @@ CSErrorCode CSChunkFile::Write(SequenceNum sn,
                    << "ChunkID: " << chunkId_
                    << ",request sn: " << sn
                    << ",chunk sn: " << metaPage_.sn;
-        return CSErrorCode::InternalError;
+        return rc == -ENOSPC ? CSErrorCode::NoSpaceError : CSErrorCode::InternalError;
     }
     // If it is a clone chunk, the bitmap will be updated
     CSErrorCode errorCode = flush();
@@ -478,7 +479,7 @@ CSErrorCode CSChunkFile::Paste(const char * buf, off_t offset, size_t length) {
                        << "ChunkID: " << chunkId_
                        << ", offset: " << offset
                        << ", length: " << length;
-            return CSErrorCode::InternalError;
+            return rc == -ENOSPC ? CSErrorCode::NoSpaceError : CSErrorCode::InternalError;
         }
     }
 

src/chunkserver/datastore/chunkserver_datastore.cpp

@@ -44,7 +44,8 @@ CSDataStore::CSDataStore(std::shared_ptr<LocalFileSystem> lfs,
       baseDir_(options.baseDir),
       chunkFilePool_(chunkFilePool),
       lfs_(lfs),
-      enableOdsyncWhenOpenChunkFile_(options.enableOdsyncWhenOpenChunkFile) {
+      enableOdsyncWhenOpenChunkFile_(options.enableOdsyncWhenOpenChunkFile),
+      waitForDiskFreedIntervalMs_(options.waitForDiskFreedIntervalMs) {
     CHECK(!baseDir_.empty()) << "Create datastore failed";
     CHECK(lfs_ != nullptr) << "Create datastore failed";
     CHECK(chunkFilePool_ != nullptr) << "Create datastore failed";