diff --git a/contrib/tiflash-proxy b/contrib/tiflash-proxy index f2e5fb8878e..6b5a8b24f01 160000 --- a/contrib/tiflash-proxy +++ b/contrib/tiflash-proxy @@ -1 +1 @@ -Subproject commit f2e5fb8878eb51492c54f1094a847e0b958c6bb8 +Subproject commit 6b5a8b24f0168262012d04c56463f8c8c1d17553 diff --git a/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.cpp b/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.cpp index 2b30f6b02ac..af5396272b6 100644 --- a/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.cpp +++ b/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.cpp @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include @@ -55,17 +56,36 @@ extern const char force_fap_worker_throw[]; extern const char force_set_fap_candidate_store_id[]; } // namespace FailPoints -FastAddPeerRes genFastAddPeerRes(FastAddPeerStatus status, std::string && apply_str, std::string && region_str) +FastAddPeerRes genFastAddPeerRes( + FastAddPeerStatus status, + std::string && apply_str, + std::string && region_str, + uint64_t shard_ver, + std::string && inner_key_str, + std::string && enc_key_str, + std::string && txn_file_ref_str) { auto * apply = RawCppString::New(apply_str); auto * region = RawCppString::New(region_str); + auto * inner_key = RawCppString::New(inner_key_str); + auto * enc_key = RawCppString::New(enc_key_str); + auto * txn_file_ref = RawCppString::New(txn_file_ref_str); return FastAddPeerRes{ .status = status, .apply_state = CppStrWithView{.inner = GenRawCppPtr(apply, RawCppPtrTypeImpl::String), .view = BaseBuffView{apply->data(), apply->size()}}, .region = CppStrWithView{.inner = GenRawCppPtr(region, RawCppPtrTypeImpl::String), .view = BaseBuffView{region->data(), region->size()}}, + .shard_ver = shard_ver, + .inner_key = CppStrWithView{.inner = GenRawCppPtr(inner_key, RawCppPtrTypeImpl::String), .view = BaseBuffView{inner_key->data(), inner_key->size()}}, + .enc_key = CppStrWithView{.inner = GenRawCppPtr(enc_key, RawCppPtrTypeImpl::String), .view = BaseBuffView{enc_key->data(), enc_key->size()}}, + .txn_file_ref = CppStrWithView{.inner = GenRawCppPtr(txn_file_ref, RawCppPtrTypeImpl::String), .view = BaseBuffView{txn_file_ref->data(), txn_file_ref->size()}}, }; } +FastAddPeerRes genFastAddPeerResFail(FastAddPeerStatus status) +{ + return genFastAddPeerRes(status, "", "", 0, "", "", ""); +} + std::vector getCandidateStoreIDsForRegion(TMTContext & tmt_context, UInt64 region_id, UInt64 current_store_id) { fiu_do_on(FailPoints::force_set_fap_candidate_store_id, { return {1234}; }); @@ -208,7 +228,7 @@ std::variant FastAddPeerImplSelect( { LOG_DEBUG(log, "No suitable candidate peer for region_id={}", region_id); GET_METRIC(tiflash_fap_task_result, type_failed_no_suitable).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); } LOG_DEBUG(log, "Begin to select checkpoint for region_id={}", region_id); @@ -269,7 +289,7 @@ std::variant FastAddPeerImplSelect( region_id, new_peer_id); GET_METRIC(tiflash_fap_task_result, type_failed_timeout).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); } SYNC_FOR("in_FastAddPeerImplSelect::before_sleep"); if (cancel_handle->blockedWaitFor(std::chrono::milliseconds(1000))) @@ -280,7 +300,7 @@ std::variant FastAddPeerImplSelect( fap_ctx->tasks_trace->leakingDiscardTask(region_id); // We immediately increase this metrics when cancel, since a canceled task may not be fetched. GET_METRIC(tiflash_fap_task_result, type_failed_cancel).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); } } } @@ -317,7 +337,7 @@ FastAddPeerRes FastAddPeerImplWrite( region_id, keyspace_id, table_id); - return genFastAddPeerRes(FastAddPeerStatus::BadData, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::BadData); } UNUSED(schema_snap); RUNTIME_CHECK_MSG(storage->engineType() == TiDB::StorageEngine::DT, "ingest into unsupported storage engine"); @@ -338,7 +358,7 @@ FastAddPeerRes FastAddPeerImplWrite( table_id); fap_ctx->cleanTask(tmt, proxy_helper, region_id, CheckpointIngestInfo::CleanReason::TiFlashCancel); GET_METRIC(tiflash_fap_task_result, type_failed_cancel).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); } DM::Segments segments; @@ -378,7 +398,7 @@ FastAddPeerRes FastAddPeerImplWrite( table_id); fap_ctx->cleanTask(tmt, proxy_helper, region_id, CheckpointIngestInfo::CleanReason::TiFlashCancel); GET_METRIC(tiflash_fap_task_result, type_failed_cancel).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); } // Write raft log to uni ps, we do this here because we store raft log seperately. @@ -413,13 +433,20 @@ FastAddPeerRes FastAddPeerImplWrite( table_id); fap_ctx->cleanTask(tmt, proxy_helper, region_id, CheckpointIngestInfo::CleanReason::TiFlashCancel); GET_METRIC(tiflash_fap_task_result, type_failed_cancel).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); } LOG_DEBUG(log, "Finish write FAP snapshot, region_id={} keyspace={} table_id={}", region_id, keyspace_id, table_id); + // Return a FastAddPeerRes with region meta under the serverless branch to generate a fap snapshot + // with correct meta + auto tmp_ps = checkpoint_info->checkpoint_data_holder->getUniversalPageStorage(); return genFastAddPeerRes( FastAddPeerStatus::Ok, apply_state.SerializeAsString(), - region_state.region().SerializeAsString()); + region_state.region().SerializeAsString(), + getShardVer(tmp_ps, region_id), + getCompactibleInnerKey(tmp_ps, keyspace_id, region_id), + getCompactibleEncKey(tmp_ps, keyspace_id, region_id), + getTxnFileRef(tmp_ps, region_id)); } // This function executes FAP phase 1 from a thread in a dedicated pool. @@ -477,7 +504,7 @@ FastAddPeerRes FastAddPeerImpl( GET_METRIC(tiflash_fap_task_result, type_failed_baddata).Increment(); // The task could stuck in AsyncTasks as Finished till fetched by resolveFapSnapshotState, // since a FastAddPeerStatus::BadData result will lead to a fallback in Proxy. - return genFastAddPeerRes(FastAddPeerStatus::BadData, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::BadData); } catch (...) { @@ -490,7 +517,7 @@ FastAddPeerRes FastAddPeerImpl( GET_METRIC(tiflash_fap_task_result, type_failed_baddata).Increment(); // The task could stuck in AsyncTasks as Finished till fetched by resolveFapSnapshotState. // since a FastAddPeerStatus::BadData result will lead to a fallback in Proxy. - return genFastAddPeerRes(FastAddPeerStatus::BadData, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::BadData); } } @@ -650,12 +677,12 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u { auto log = Logger::get("FastAddPeer"); if (!server->tmt->getContext().getSharedContextDisagg()->isDisaggregatedStorageMode()) - return genFastAddPeerRes(FastAddPeerStatus::OtherError, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::OtherError); auto fap_ctx = server->tmt->getContext().getSharedContextDisagg()->fap_context; if (fap_ctx == nullptr) { LOG_WARNING(log, "FAP Context is not initialized. Should only enable FAP in DisaggregatedStorageMode."); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); } if (!fap_ctx->tasks_trace->isScheduled(region_id)) { @@ -682,7 +709,7 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u new_peer_id); // It is already canceled in queue. GET_METRIC(tiflash_fap_task_result, type_failed_cancel).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); }); if (res) { @@ -699,7 +726,7 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u new_peer_id, region_id); GET_METRIC(tiflash_fap_task_result, type_failed_other).Increment(); - return genFastAddPeerRes(FastAddPeerStatus::OtherError, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::OtherError); } } @@ -747,10 +774,10 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u } GET_METRIC(tiflash_fap_task_state, type_blocking_cancel_stage).Decrement(); // Return Canceled because it is cancel from outside FAP worker. - return genFastAddPeerRes(FastAddPeerStatus::Canceled, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::Canceled); } LOG_DEBUG(log, "Task is still pending new_peer_id={} region_id={}", new_peer_id, region_id); - return genFastAddPeerRes(FastAddPeerStatus::WaitForData, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::WaitForData); } } catch (const Exception & e) @@ -762,7 +789,7 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u region_id, new_peer_id, e.message())); - return genFastAddPeerRes(FastAddPeerStatus::OtherError, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::OtherError); } catch (...) { @@ -772,7 +799,7 @@ FastAddPeerRes FastAddPeer(EngineStoreServerWrap * server, uint64_t region_id, u "Failed when try to restore from checkpoint region_id={} new_peer_id={}", region_id, new_peer_id)); - return genFastAddPeerRes(FastAddPeerStatus::OtherError, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::OtherError); } } diff --git a/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.h b/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.h index ae486207b87..a67adbd23d3 100644 --- a/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.h +++ b/dbms/src/Storages/KVStore/MultiRaft/Disagg/FastAddPeer.h @@ -25,7 +25,15 @@ class Region; using RegionPtr = std::shared_ptr; using CheckpointRegionInfoAndData = std::tuple; -FastAddPeerRes genFastAddPeerRes(FastAddPeerStatus status, std::string && apply_str, std::string && region_str); +FastAddPeerRes genFastAddPeerRes( + FastAddPeerStatus status, + std::string && apply_str, + std::string && region_str, + uint64_t shard_ver, + std::string && inner_key_str, + std::string && enc_key_str, + std::string && txn_file_ref_str); +FastAddPeerRes genFastAddPeerResFail(FastAddPeerStatus status); std::variant FastAddPeerImplSelect( TMTContext & tmt, const TiFlashRaftProxyHelper * proxy_helper, diff --git a/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.cpp b/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.cpp new file mode 100644 index 00000000000..71f7bc586c3 --- /dev/null +++ b/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.cpp @@ -0,0 +1,285 @@ +// Copyright 2024 PingCAP, Ltd. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include + +namespace DB +{ +// make_keyspace_prefix +String makeKeyspacePrefix(uint32_t keyspace_id, uint8_t suffix) +{ + WriteBufferFromOwnString buff; + writeChar(UniversalPageIdFormat::KV_PREFIX, buff); + // pub const KEYSPACE_META_PREFIX_KEY: &[u8] = &[LOCAL_PREFIX, KEYSPACE_META_PREFIX]; + // pub const KEYSPACE_META_PREFIX: u8 = 0x04; + writeChar(0x01, buff); + writeChar(0x04, buff); + UniversalPageIdFormat::encodeUInt32(keyspace_id, buff); + writeChar(suffix, buff); + return buff.releaseStr(); +} + +// make_region_prefix +String makeRegionPrefix(uint64_t region_id, uint8_t suffix) +{ + WriteBufferFromOwnString buff; + writeChar(UniversalPageIdFormat::KV_PREFIX, buff); + // pub const REGION_RAFT_PREFIX: u8 = 0x02; + // pub const REGION_RAFT_PREFIX_KEY: &[u8] = &[LOCAL_PREFIX, REGION_RAFT_PREFIX]; + writeChar(0x01, buff); + writeChar(0x02, buff); + UniversalPageIdFormat::encodeUInt64(region_id, buff); + writeChar(suffix, buff); + return buff.releaseStr(); +} + +#if SERVERLESS_PROXY == 0 +// pub const KEYSPACE_INNER_KEY_OFF_SUFFIX: u8 = 0x01; +String getKeyspaceInnerKey(UniversalPageStoragePtr, uint32_t) +{ + return ""; +} + +// pub const REGION_INNER_KEY_OFF_SUFFIX: u8 = 0x06; +String getRegionInnerKey(UniversalPageStoragePtr, uint64_t) +{ + return ""; +} + +String getCompactibleInnerKey(UniversalPageStoragePtr, uint32_t, uint64_t) +{ + return ""; +} + +// pub const REGION_ENCRYPTION_KEY_SUFFIX: u8 = 0x07; +String getRegionEncKey(UniversalPageStoragePtr, uint64_t) +{ + return ""; +} + +// pub const KEYSPACE_ENCRYPTION_KEY_SUFFIX: u8 = 0x02; +String getKeyspaceEncKey(UniversalPageStoragePtr, uint32_t) +{ + return ""; +} + +String getCompactibleEncKey(UniversalPageStoragePtr, uint32_t, uint64_t) +{ + return ""; +} + +// pub const REGION_META_VERSION_SUFFIX: u8 = 0x09; +UInt64 getShardVer(UniversalPageStoragePtr, uint64_t) +{ + return 0; +} + +// pub const REGION_TXN_FILE_LOCKS_SUFFIX: u8 = 0x08; +String getTxnFileRef(UniversalPageStoragePtr, uint64_t) +{ + return ""; +} +#else +// pub const KEYSPACE_INNER_KEY_OFF_SUFFIX: u8 = 0x01; +String getKeyspaceInnerKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id) +{ + auto key = makeKeyspacePrefix(keyspace_id, 0x01); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return String(page.data.begin(), page.data.size()); + } + else + { + return ""; + } + } + catch (...) + { + return ""; + } +} + +// pub const REGION_INNER_KEY_OFF_SUFFIX: u8 = 0x06; +String getRegionInnerKey(UniversalPageStoragePtr uni_ps, uint64_t region_id) +{ + auto key = makeRegionPrefix(region_id, 0x06); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return String(page.data.begin(), page.data.size()); + } + else + { + return ""; + } + } + catch (...) + { + return ""; + } +} + +String getCompactibleInnerKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id, uint64_t region_id) +{ + auto keyspace = getKeyspaceInnerKey(uni_ps, keyspace_id); + if unlikely (keyspace.empty()) + { + auto region = getRegionInnerKey(uni_ps, region_id); + if unlikely (region.empty()) + { + LOG_INFO( + DB::Logger::get(), + "Failed to find compactible inner key, region_id={}, keyspace_id={}", + region_id, + keyspace_id); + } + return region; + } + else + { + return keyspace; + } +} + +// pub const REGION_ENCRYPTION_KEY_SUFFIX: u8 = 0x07; +String getRegionEncKey(UniversalPageStoragePtr uni_ps, uint64_t region_id) +{ + auto key = makeRegionPrefix(region_id, 0x07); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return String(page.data.begin(), page.data.size()); + } + else + { + return ""; + } + } + catch (...) + { + return ""; + } +} + +// pub const KEYSPACE_ENCRYPTION_KEY_SUFFIX: u8 = 0x02; +String getKeyspaceEncKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id) +{ + auto key = makeKeyspacePrefix(keyspace_id, 0x02); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return String(page.data.begin(), page.data.size()); + } + else + { + return ""; + } + } + catch (...) + { + return ""; + } +} + +String getCompactibleEncKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id, uint64_t region_id) +{ + auto keyspace = getKeyspaceEncKey(uni_ps, keyspace_id); + if unlikely (keyspace.empty()) + { + auto region = getRegionEncKey(uni_ps, region_id); + if unlikely (region.empty()) + { + LOG_INFO( + DB::Logger::get(), + "Failed to find compactible enc key, region_id={}, keyspace_id={}", + region_id, + keyspace_id); + } + return region; + } + else + { + return keyspace; + } +} + +// pub const REGION_META_VERSION_SUFFIX: u8 = 0x09; +UInt64 getShardVer(UniversalPageStoragePtr uni_ps, uint64_t region_id) +{ + auto key = makeRegionPrefix(region_id, 0x09); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return UniversalPageIdFormat::decodeUInt64(page.data.data()); + } + else + { + LOG_INFO(DB::Logger::get(), "Failed to find shard_ver, region_id={}, key={}", region_id, key); + return 0; + } + } + catch (...) + { + LOG_INFO( + DB::Logger::get(), + "Failed to find shard_ver, region_id={}, key={}", + region_id, + Redact::keyToHexString(key.data(), key.size())); + return 0; + } +} + +// pub const REGION_TXN_FILE_LOCKS_SUFFIX: u8 = 0x08; +String getTxnFileRef(UniversalPageStoragePtr uni_ps, uint64_t region_id) +{ + auto key = makeRegionPrefix(region_id, 0x08); + try + { + auto page = uni_ps->read(key, /*read_limiter*/ nullptr, {}, /*throw_on_not_exist*/ false); + if (page.isValid()) + { + return String(page.data.begin(), page.data.size()); + } + else + { + LOG_INFO(DB::Logger::get(), "Failed to find txn ref, region_id={}, key={}", region_id, key); + return ""; + } + } + catch (...) + { + LOG_INFO( + DB::Logger::get(), + "Failed to find txn ref, region_id={}, key={}", + region_id, + Redact::keyToHexString(key.data(), key.size())); + return ""; + } +} +#endif + +} // namespace DB diff --git a/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.h b/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.h new file mode 100644 index 00000000000..46c84da0d0c --- /dev/null +++ b/dbms/src/Storages/KVStore/MultiRaft/Disagg/ServerlessUtils.h @@ -0,0 +1,31 @@ +// Copyright 2024 PingCAP, Ltd. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include + +namespace DB +{ +String makeKeyspacePrefix(uint32_t keyspace_id, uint8_t suffix); +String makeRegionPrefix(uint64_t region_id, uint8_t suffix); +String getKeyspaceInnerKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id); +String getRegionInnerKey(UniversalPageStoragePtr uni_ps, uint64_t region_id); +String getCompactibleInnerKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id, uint64_t region_id); +String getRegionEncKey(UniversalPageStoragePtr uni_ps, uint64_t region_id); +String getKeyspaceEncKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id); +String getCompactibleEncKey(UniversalPageStoragePtr uni_ps, uint32_t keyspace_id, uint64_t region_id); +UInt64 getShardVer(UniversalPageStoragePtr uni_ps, uint64_t region_id); +String getTxnFileRef(UniversalPageStoragePtr uni_ps, uint64_t region_id); +} // namespace DB diff --git a/dbms/src/Storages/KVStore/TiKVHelpers/TiKVRecordFormat.h b/dbms/src/Storages/KVStore/TiKVHelpers/TiKVRecordFormat.h index ac3b99fc01c..37ed4b65775 100644 --- a/dbms/src/Storages/KVStore/TiKVHelpers/TiKVRecordFormat.h +++ b/dbms/src/Storages/KVStore/TiKVHelpers/TiKVRecordFormat.h @@ -87,6 +87,11 @@ inline UInt64 encodeUInt64(const UInt64 x) return toBigEndian(x); } +inline UInt32 encodeUInt32(const UInt32 x) +{ + return toBigEndian(x); +} + inline UInt64 encodeInt64(const Int64 x) { return encodeUInt64(static_cast(x) ^ SIGN_MASK); diff --git a/dbms/src/Storages/KVStore/tests/gtest_kvstore_fast_add_peer.cpp b/dbms/src/Storages/KVStore/tests/gtest_kvstore_fast_add_peer.cpp index 944c82a96c6..37f33292f7f 100644 --- a/dbms/src/Storages/KVStore/tests/gtest_kvstore_fast_add_peer.cpp +++ b/dbms/src/Storages/KVStore/tests/gtest_kvstore_fast_add_peer.cpp @@ -449,7 +449,7 @@ try fap_context->tasks_trace->addTask(region_id, [&]() { // Keep the task in `tasks_trace` to prevent from canceling. std::scoped_lock wait_exe_lock(exe_mut); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); FastAddPeerImplWrite(global_context.getTMTContext(), proxy_helper.get(), region_id, 2333, std::move(mock_data), 0); exe_lock.unlock(); @@ -517,7 +517,7 @@ try fap_context->tasks_trace->addTask(region_id, [&]() { // Keep the task in `tasks_trace` to prevent from canceling. std::scoped_lock wait_exe_lock(exe_mut); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); FastAddPeerImplWrite(global_context.getTMTContext(), proxy_helper.get(), region_id, 2333, std::move(mock_data), 0); exe_lock.unlock(); @@ -550,7 +550,7 @@ try fap_context->tasks_trace->addTask(region_id, [&]() { // Keep the task in `tasks_trace` to prevent from canceling. std::scoped_lock wait_exe_lock(exe_mut); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); // Will generate and persist some information in local ps, which will not be uploaded. FastAddPeerImplWrite(global_context.getTMTContext(), proxy_helper.get(), region_id, 2333, std::move(mock_data), 0); @@ -821,9 +821,7 @@ try auto & global_context = TiFlashTestEnv::getGlobalContext(); auto fap_context = global_context.getSharedContextDisagg()->fap_context; uint64_t region_id = 1; - fap_context->tasks_trace->addTask(region_id, []() { - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); - }); + fap_context->tasks_trace->addTask(region_id, []() { return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); EXPECT_THROW( FastAddPeerImplWrite( global_context.getTMTContext(), @@ -869,7 +867,7 @@ try fap_context->tasks_trace->addTask(region_id, [&]() { // Keep the task in `tasks_trace` to prevent from canceling. std::scoped_lock wait_exe_lock(exe_mut); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); FastAddPeerImplWrite(global_context.getTMTContext(), proxy_helper.get(), region_id, 2333, std::move(mock_data), 0); exe_lock.unlock(); @@ -974,7 +972,7 @@ try fap_context->tasks_trace->addTask(region_id, [&]() { // Keep the task in `tasks_trace` to prevent from canceling. std::scoped_lock wait_exe_lock(exe_mut); - return genFastAddPeerRes(FastAddPeerStatus::NoSuitable, "", ""); + return genFastAddPeerResFail(FastAddPeerStatus::NoSuitable); }); // Mock that the storage instance have been dropped diff --git a/dbms/src/Storages/Page/V3/CheckpointFile/CPFilesWriter.cpp b/dbms/src/Storages/Page/V3/CheckpointFile/CPFilesWriter.cpp index 214d459d801..44ca8e6933d 100644 --- a/dbms/src/Storages/Page/V3/CheckpointFile/CPFilesWriter.cpp +++ b/dbms/src/Storages/Page/V3/CheckpointFile/CPFilesWriter.cpp @@ -97,6 +97,12 @@ CPDataDumpStats CPFilesWriter::writeEditsAndApplyCheckpointInfo( // and collect the lock files from applied entries. auto & records = edits.getMutRecords(); write_down_stats.num_records = records.size(); + LOG_DEBUG( + log, + "Prepare to dump {} records, sequence={}, manifest_file_id={}", + write_down_stats.num_records, + sequence, + manifest_file_id); for (auto & rec_edit : records) { StorageType id_storage_type = StorageType::Unknown; diff --git a/dbms/src/Storages/Page/V3/Universal/UniversalPageIdFormatImpl.h b/dbms/src/Storages/Page/V3/Universal/UniversalPageIdFormatImpl.h index 04b68da7719..fc3deea49c3 100644 --- a/dbms/src/Storages/Page/V3/Universal/UniversalPageIdFormatImpl.h +++ b/dbms/src/Storages/Page/V3/Universal/UniversalPageIdFormatImpl.h @@ -291,7 +291,13 @@ struct UniversalPageIdFormat return StorageType::Unknown; } -private: +public: + static inline void encodeUInt32(const UInt32 x, WriteBuffer & ss) + { + auto u = toBigEndian(x); + ss.write(reinterpret_cast(&u), sizeof(u)); + } + static inline void encodeUInt64(const UInt64 x, WriteBuffer & ss) { auto u = toBigEndian(x); @@ -304,6 +310,7 @@ struct UniversalPageIdFormat return toBigEndian(v); } +private: static String getSubPrefix(StorageType type) { switch (type)