MB-58135: Warmup: Ignore corrupted accessLog entries

When loading the access logs during warmup, any read errors
(MutationLog::ReadException) are caught and cause that file to be
skipped; however other errors due to logical corruption of the file
are not. If an invalid magic is found in the access log entry (or
similar logical error), then the thrown std::invalid_argument is not
caught and will terminate the process as it is not caught at any
higher levels.

As such, change to catch any std::exception thrown.

Change-Id: I7cbfdd000a18d1269c886b0636534f0b08561945
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/199027
Tested-by: Build Bot <[email protected]>
Reviewed-by: Paolo Cocchi <[email protected]>
Well-Formed: Restriction Checker

Author: daverigby

engines/ep/src/warmup.cc

@@ -1786,7 +1786,7 @@ void Warmup::loadingAccessLog(uint16_t shardId)
                 (size_t)-1) {
                 success = true;
             }
-        } catch (MutationLog::ReadException &e) {
+        } catch (const std::exception& e) {
             corruptAccessLog = true;
             EP_LOG_WARN("Error reading warmup access log:  {}", e.what());
         }
@@ -1804,7 +1804,7 @@ void Warmup::loadingAccessLog(uint16_t shardId)
                     (size_t)-1) {
                     success = true;
                 }
-            } catch (MutationLog::ReadException &e) {
+            } catch (const std::exception& e) {
                 corruptAccessLog = true;
                 EP_LOG_WARN("Error reading old access log:  {}", e.what());
             }

engines/ep/tests/mock/mock_access_scanner.h

@@ -0,0 +1,37 @@
+/*
+ *     Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#pragma once
+
+#include "access_scanner.h"
+
+/***
+ * Test class to expose the behaviour needed to create an ItemAccessVisitor
+ */
+class MockAccessScanner : public AccessScanner {
+public:
+    MockAccessScanner(KVBucket& _store,
+                      Configuration& conf,
+                      EPStats& st,
+                      double sleeptime = 0,
+                      bool useStartTime = false,
+                      bool completeBeforeShutdown = false)
+        : AccessScanner(_store,
+                        conf,
+                        st,
+                        sleeptime,
+                        useStartTime,
+                        completeBeforeShutdown) {
+    }
+
+    void public_createAndScheduleTask(const size_t shard) {
+        return createAndScheduleTask(shard);
+    }
+};

engines/ep/tests/mock/mock_mutation_log.h

@@ -0,0 +1,27 @@
+/*
+ *     Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#pragma once
+
+#include "mutation_log.h"
+
+class MockMutationLog : public MutationLog {
+public:
+    using MutationLog::MutationLog;
+
+    /* NOLINTNEXTLINE(modernize-avoid-c-arrays) */
+    std::unique_ptr<uint8_t[]>& public_getBlockBuffer() {
+        return blockBuffer;
+    }
+
+    size_t public_getBlockPos() {
+        return blockPos;
+    }
+};

engines/ep/tests/module_tests/evp_store_warmup_test.cc

@@ -13,6 +13,7 @@
 #include "../mock/mock_dcp_producer.h"
 #include "../mock/mock_ep_bucket.h"
 #include "../mock/mock_item_freq_decayer.h"
+#include "../mock/mock_mutation_log.h"
 #include "../mock/mock_kvstore.h"
 #include "../mock/mock_synchronous_ep_engine.h"
 #include "checkpoint_manager.h"
@@ -666,6 +667,57 @@ TEST_F(WarmupTest, MB_31450) {
     MB_31450(false);
 }
 
+TEST_F(WarmupTest, MB_58135_CorruptAccessLog) {
+    setVBucketStateAndRunPersistTask(vbid, vbucket_state_active);
+
+    auto key = makeStoredDocKey("key");
+    for (int i = 0; i < 1; i++) {
+        store_item(vbid, makeStoredDocKey("key" + std::to_string(i)), "value");
+    }
+    flush_vbucket_to_disk(vbid, 1);
+
+    // Create an access log for each shard (warmup only uses access logs if it
+    // has a complete set). First one will be valid, second one will be
+    // corrupted.
+    ASSERT_EQ(2, engine->getWorkLoadPolicy().getNumShards());
+    {
+        MutationLog mlog("access_log.0");
+        mlog.open();
+        mlog.newItem(vbid, key);
+    }
+    {
+        MockMutationLog mlog("access_log.1");
+        mlog.open();
+        mlog.newItem(vbid, key);
+        bool modified = false;
+        for (size_t i = 0; i < mlog.public_getBlockPos(); i++) {
+            // Corrupt the magic
+            auto& c = mlog.public_getBlockBuffer()[i];
+            if (c == MutationLogEntryV3::MagicMarker) {
+                c = 0xff;
+                modified = true;
+            }
+        }
+        ASSERT_TRUE(modified);
+    }
+    // Copy corrupted access log to .old so we check both
+    // code paths (warmup will fallback to .old if the main one cannot be read).
+    namespace fs = boost::filesystem;
+    auto alog = fs::path("access_log.1");
+    EXPECT_TRUE(fs::exists(alog));
+    auto alog_old = fs::path("access_log.1.old");
+    fs::remove(alog_old);
+    fs::copy_file(alog, alog_old);
+    EXPECT_TRUE(fs::exists(alog_old));
+
+    // Test: restart and warmup. Should not crash, warmup should succeed
+    // without access log.
+    resetEngineAndWarmup("alog_path=access_log");
+
+    auto* warmup = engine->getKVBucket()->getWarmup();
+    EXPECT_EQ(WarmupState::State::Done, warmup->getWarmupState());
+}
+
 // Test fixture for Durability-related Warmup tests.
 class DurabilityWarmupTest : public DurabilityKVBucketTest {
 protected: