fix review feedback on integrity follow-ups

Author: charpty

kv_cache_manager/client/src/transfer_client_impl.cc

@@ -219,6 +219,11 @@ ClientErrorCode TransferClientImpl::Init(const std::string &client_config, const
                 KVCM_LOG_ERROR("sdk_buffer_check_pool init faild, sdk_check_cell_num[%lu], max_check_iov_num[%lu]",
                                sdk_check_cell_num,
                                max_check_iov_num_);
+                client_config_.reset();
+                sdk_wrapper_.reset();
+                sdk_buffer_check_pool_.reset();
+                meta_checksum_enabled_ = false;
+                is_check_buffer_ = false;
                 return ER_INIT_CHECK_BUFFER_ERROR;
             }
         }

kv_cache_manager/config/registry_manager.cc

@@ -195,6 +195,11 @@ ErrorCode RegistryManager::UpdateStorage(RequestContext *request_context,
     std::unique_lock<std::shared_mutex> lock(mutex_);
     const auto &trace_id = request_context->request_id();
     const auto &global_unique_name = storage_config.global_unique_name();
+    std::string invalid_fields;
+    if (!storage_config.ValidateRequiredFields(invalid_fields)) {
+        PREFIX_LOG_S(WARN, "update storage failed: invalid config, fields[%s]", invalid_fields.c_str());
+        return EC_BADARGS;
+    }
     // 重建期间短暂不可用
     auto ec = RemoveStorage(request_context, global_unique_name);
     RETURN_IF_EC_NOT_OK_WITH_LOG_S(WARN, ec, "update storage failed: remove storage failed");

kv_cache_manager/config/test/registry_manager_local_backend_test.cc

@@ -743,4 +743,31 @@ TEST_F(RegistryManagerLocalBackendTest, TestAddStorageRejectsInvalidIntegrity) {
     }
 }
 
+TEST_F(RegistryManagerLocalBackendTest, TestUpdateStorageRejectsInvalidIntegrityBeforeRemovingExistingStorage) {
+    std::string local_path = GetPrivateTestRuntimeDataPath() + "_registry_local_backend_update_reject_integrity";
+    std::string uri = "local://" + local_path + "?cluster_name=test";
+    ASSERT_TRUE(InitRegistryManager(uri));
+
+    std::shared_ptr<NfsStorageSpec> original_spec = GetDefaultNfsStorageSpec();
+    original_spec->set_root_path(GetPrivateTestRuntimeDataPath() + "/original_nfs_root/");
+    StorageConfig original_config(DataStorageType::DATA_STORAGE_TYPE_NFS, "storage1", original_spec);
+    ASSERT_EQ(EC_OK, registry_manager_->AddStorage(request_context_.get(), original_config));
+    ASSERT_TRUE(registry_manager_->data_storage_manager()->GetDataStorageBackend("storage1"));
+
+    DataIntegrityConfig integrity;
+    integrity.set_enable_inline_header(true);
+    std::shared_ptr<NfsStorageSpec> invalid_spec = GetDefaultNfsStorageSpec();
+    invalid_spec->set_root_path(GetPrivateTestRuntimeDataPath() + "/invalid_nfs_root/");
+    StorageConfig invalid_config(DataStorageType::DATA_STORAGE_TYPE_NFS, "storage1", invalid_spec);
+    invalid_config.set_integrity(integrity);
+
+    EXPECT_EQ(EC_BADARGS, registry_manager_->UpdateStorage(request_context_.get(), invalid_config, true));
+
+    auto storage = registry_manager_->data_storage_manager()->GetDataStorageBackend("storage1");
+    ASSERT_TRUE(storage);
+    auto spec = std::dynamic_pointer_cast<NfsStorageSpec>(storage->GetStorageConfig().storage_spec());
+    ASSERT_TRUE(spec);
+    EXPECT_EQ(GetPrivateTestRuntimeDataPath() + "/original_nfs_root/", spec->root_path());
+}
+
 } // namespace kv_cache_manager

kv_cache_manager/manager/cache_manager.cc

@@ -1413,6 +1413,8 @@ ErrorCode CacheManager::GenWriteLocation(RequestContext *request_context,
 
 namespace {
 
+std::string LegacyVineyardStorageNameFromInstance(const std::string &instance_id) { return "v6d_" + instance_id; }
+
 std::shared_ptr<DataStorageBackend>
 LookupEventReportingBackend(const std::shared_ptr<RegistryManager> &registry_manager, const std::string &instance_id) {
     if (!registry_manager || !registry_manager->data_storage_manager()) {
@@ -1424,6 +1426,11 @@ LookupEventReportingBackend(const std::shared_ptr<RegistryManager> &registry_man
     }
     auto ig = registry_manager->GetInstanceGroupConfig(group_name);
     if (!ig || ig->event_reporting_storage_candidates().empty()) {
+        auto legacy_backend = registry_manager->data_storage_manager()->GetDataStorageBackend(
+            LegacyVineyardStorageNameFromInstance(instance_id));
+        if (legacy_backend && dynamic_cast<EventReportingBackend *>(legacy_backend.get())) {
+            return legacy_backend;
+        }
         return nullptr;
     }
     auto dsm = registry_manager->data_storage_manager();

kv_cache_manager/manager/test/cache_manager_test.cc

@@ -3264,4 +3264,33 @@ TEST_F(CacheManagerTest, TestGetCacheLocationsByBackendWithBackendSelectors) {
 
     dsm->storage_map_.erase("vineyard_default");
 }
+
+TEST_F(CacheManagerTest, TestReportEventUsesLegacyVineyardBackendWhenEventCandidatesMissing) {
+    auto metrics_registry = cache_manager_->metrics_registry_;
+    auto vineyard_backend = std::make_shared<VineyardBackend>(metrics_registry);
+    StorageConfig v6d_config;
+    v6d_config.set_global_unique_name("v6d_test_instance");
+    v6d_config.set_type(DataStorageType::DATA_STORAGE_TYPE_VINEYARD);
+    v6d_config.set_storage_spec(std::make_shared<VineyardStorageSpec>());
+    ASSERT_EQ(EC_OK, vineyard_backend->Open(v6d_config, "test_trace"));
+
+    auto dsm = registry_manager_->data_storage_manager_;
+    dsm->storage_map_["v6d_test_instance"] = vineyard_backend;
+    registry_manager_->instance_group_configs_["default"]->set_event_reporting_storage_candidates({});
+
+    proto::meta::ReportEventRequest req;
+    req.set_instance_id("test_instance");
+    req.set_host_ip_port("192.168.10.1:8080");
+    req.set_storage_type(proto::meta::ST_VINEYARD);
+    auto *reg = req.add_events();
+    reg->set_event_type(proto::meta::EVENT_NODE_REGISTER);
+    reg->mutable_node_register()->add_mediums("mem");
+
+    proto::meta::ReportEventResponse resp;
+    ASSERT_EQ(EC_OK, cache_manager_->ReportEvent(request_context_.get(), &req, &resp));
+    EXPECT_TRUE(vineyard_backend->IsNodeAvailable("test_instance", "192.168.10.1:8080"));
+
+    dsm->storage_map_.erase("v6d_test_instance");
+}
+
 } // namespace kv_cache_manager