[feat] Re-use active block (#334)

reuse act

Co-authored-by: lijiachen <lijiachen19@huawei.com>

Author: Lijiachen1018

ucm/store/nfsstore/cc/domain/space/space_manager.cc

@@ -25,6 +25,9 @@
 #include "file/file.h"
 #include "logger/logger.h"
 #include "space_shard_temp_layout.h"
+#include <chrono>
+
+constexpr auto MIN_REUSE_BLOCK_AGE = 300; // 5 minutes
 
 namespace UC {
 
@@ -96,9 +99,28 @@ Status SpaceManager::NewBlock(const std::string& blockId)
     if (status.Failure()) {
         if (status != Status::DuplicateKey()) {
             UC_ERROR("Failed({}) to new block({}).", status, blockId);
+            return status;
+        }
+        // Reuse the active block if it is not accessed within the last 5 minutes
+        status = file->Open(IFile::OpenFlag::READ_WRITE);
+        if (status.Failure()) {
+            UC_ERROR("Failed({}) to open file({}).", status, file->Path());
+            return status;
+        }
+        IFile::FileStat st{};
+        status = file->Stat(st);
+        if (status.Failure()) {
+            UC_ERROR("Failed({}) to stat file({}).", status, file->Path());
+            return status;
+        }
+        const auto now = std::chrono::system_clock::now();
+        const auto lastAccess = std::chrono::system_clock::from_time_t(st.st_atime);
+        if (now - lastAccess <= std::chrono::seconds(MIN_REUSE_BLOCK_AGE)) {
+            UC_ERROR("Block({}) is active, cannot reuse it.", blockId);
+            return Status::DuplicateKey();
         }
-        return status;
     }
+
     status = file->Truncate(this->blockSize_);
     if (status.Failure()) {
         UC_ERROR("Failed({}) to new block({}).", status, blockId);

ucm/store/test/case/nfsstore/space_manager_test.cc

@@ -21,8 +21,10 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  * */
+#include <utime.h>
 #include "cmn/path_base.h"
 #include "space/space_manager.h"
+#include "file/file.h"
 
 class UCSpaceManagerTest : public UC::PathBase {};
 
@@ -88,4 +90,36 @@ TEST_F(UCSpaceManagerTest, IterAllBlockFile)
     count = 0;
     while (!layout->NextDataFilePath(iter).empty()) { count++; }
     ASSERT_EQ(count, 3);
+}
+
+TEST_F(UCSpaceManagerTest, NewBlockReuseIfActiveAccessedLongAgo)
+{
+    UC::SpaceManager spaceMgr;
+    constexpr size_t blockSize = 1024 * 1024;
+    constexpr size_t capacity = blockSize * 1024;
+    ASSERT_EQ(spaceMgr.Setup({this->Path()}, blockSize, false, capacity), UC::Status::OK());
+    const auto* layout = spaceMgr.GetSpaceLayout();
+    ASSERT_NE(layout, nullptr);
+
+    const std::string block1 = "a1b2c3d4e5f6789012345678901234ab";
+    auto parent = UC::File::Make(layout->DataFileParent(block1, /*activated=*/true));
+    ASSERT_NE(parent, nullptr);
+    ASSERT_EQ(parent->MkDir(), UC::Status::OK());
+
+    const auto activePath = layout->DataFilePath(block1, /*activated=*/true);
+    auto activeFile = UC::File::Make(activePath);
+    ASSERT_NE(activeFile, nullptr);
+    ASSERT_EQ(activeFile->Open(UC::IFile::OpenFlag::CREATE | UC::IFile::OpenFlag::READ_WRITE), UC::Status::OK());
+    activeFile->Close();
+
+    // NewBlock should return DuplicateKey because the file is recent
+    ASSERT_EQ(spaceMgr.NewBlock(block1), UC::Status::DuplicateKey());
+
+    // Set atime to 10 minutes ago so it is not considered recent
+    struct utimbuf newTime;
+    auto tp = time(nullptr) - 600;
+    newTime.modtime = tp;
+    newTime.actime = tp;
+    utime(activePath.c_str(), &newTime);
+    ASSERT_EQ(spaceMgr.NewBlock(block1), UC::Status::OK());
 }