Pass componentId to CheckFunction by enum, use different default versions for different components, initialize all static values on start, KIKIMR-15989

Pass componentId to CheckFunction by enum, use different default versions for different components

Intermediate

15 files changed, 123 insertions, 95 deletions

diff --git a/ydb/core/actorlib_impl/test_interconnect_ut.cpp b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
index 527bb50c89..53fef9b9f9 100644
--- a/ydb/core/actorlib_impl/test_interconnect_ut.cpp
+++ b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
@@ -727,7 +727,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                     }
 
                     return TCompatibilityInfo::CheckCompatibility(current, &peerPB,
-                        (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                        NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
         });
         runtime.Initialize(TAppPrepare().Unwrap());
@@ -823,7 +823,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                         }
 
                         return TCompatibilityInfo::CheckCompatibility(node0.get(), &peerPB,
-                            (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                            NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                     };
 
                 common->ValidateCompatibilityOldFormat =
@@ -832,7 +832,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                             return true;
                         }
                         return TCompatibilityInfo::CheckCompatibility(node0.get(), *peer,
-                            (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                            NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                     };
             } else {
                 common->VersionInfo = TInterconnectProxyCommon::TVersionInfo{
diff --git a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.darwin-x86_64.txt b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.darwin-x86_64.txt
index 8013fe24c6..4a92bebaed 100644
--- a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.darwin-x86_64.txt
+++ b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.darwin-x86_64.txt
@@ -48,6 +48,7 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/main.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/sanitize_groups.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/scrub_fast.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
@@ -58,7 +59,6 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/discover.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/multiget.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/patch.cpp
-  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
 )
 set_property(
   TARGET
diff --git a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-aarch64.txt b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-aarch64.txt
index cb5ca4276e..3569b1842a 100644
--- a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-aarch64.txt
+++ b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-aarch64.txt
@@ -51,6 +51,7 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/main.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/sanitize_groups.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/scrub_fast.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
@@ -61,7 +62,6 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/discover.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/multiget.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/patch.cpp
-  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
 )
 set_property(
   TARGET
diff --git a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-x86_64.txt b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-x86_64.txt
index 52627d49ca..94b197b26b 100644
--- a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-x86_64.txt
+++ b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.linux-x86_64.txt
@@ -52,6 +52,7 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/main.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/sanitize_groups.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/scrub_fast.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
@@ -62,7 +63,6 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/discover.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/multiget.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/patch.cpp
-  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
 )
 set_property(
   TARGET
diff --git a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.windows-x86_64.txt b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.windows-x86_64.txt
index 96191d7fa0..d8833f79da 100644
--- a/ydb/core/blobstorage/ut_blobstorage/CMakeLists.windows-x86_64.txt
+++ b/ydb/core/blobstorage/ut_blobstorage/CMakeLists.windows-x86_64.txt
@@ -41,6 +41,7 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/incorrect_queries.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/main.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/mirror3of4.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/sanitize_groups.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/scrub_fast.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/snapshots.cpp
@@ -51,7 +52,6 @@ target_sources(ydb-core-blobstorage-ut_blobstorage PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/discover.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/multiget.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/patch.cpp
-  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
 )
 set_property(
   TARGET
diff --git a/ydb/core/blobstorage/ut_blobstorage/lib/env.h b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
index 6264bcad5b..50f65260ea 100644
--- a/ydb/core/blobstorage/ut_blobstorage/lib/env.h
+++ b/ydb/core/blobstorage/ut_blobstorage/lib/env.h
@@ -4,6 +4,7 @@
 
 #include "node_warden_mock.h"
 
+#include <ydb/core/driver_lib/version/version.h>
 #include <library/cpp/testing/unittest/registar.h>
 
 struct TEnvironmentSetup {
diff --git a/ydb/core/blobstorage/ut_blobstorage/recovery.cpp b/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
index 4358981fcd..efb4607bfa 100644
--- a/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
@@ -2,6 +2,7 @@
 #include <ydb/core/driver_lib/version/version.h>
 #include <ydb/core/driver_lib/version/ut/ut_helpers.h>
 #include <library/cpp/testing/unittest/registar.h>
+#include <google/protobuf/text_format.h>
 
 Y_UNIT_TEST_SUITE(CompatibilityInfo) {
     using EComponentId = NKikimrConfig::TCompatibilityRule::EComponentId;
@@ -63,7 +64,9 @@ Y_UNIT_TEST_SUITE(CompatibilityInfo) {
         auto oldInfo = oldInfoConstructor.ToPB();
         auto newInfo = newInfoConstructor.ToPB();
 
+        TCompatibilityInfo::Initialize();
         TCompatibilityInfoTest::Reset(&oldInfo);
+
         TEnvironmentSetup env{{
             .NodeCount = 1,
             .Erasure = TBlobStorageGroupType::ErasureNone,
diff --git a/ydb/core/blobstorage/ut_blobstorage/ya.make b/ydb/core/blobstorage/ut_blobstorage/ya.make
index 6fd28749c2..eabbb0e8a7 100644
--- a/ydb/core/blobstorage/ut_blobstorage/ya.make
+++ b/ydb/core/blobstorage/ut_blobstorage/ya.make
@@ -24,6 +24,7 @@ SRCS(
     incorrect_queries.cpp
     main.cpp
     mirror3of4.cpp
+    recovery.cpp
     sanitize_groups.cpp
     scrub_fast.cpp
     snapshots.cpp
@@ -38,7 +39,6 @@ IF (BUILD_TYPE != "DEBUG")
         discover.cpp
         multiget.cpp
         patch.cpp
-        recovery.cpp
     )
 ELSE ()
     MESSAGE(WARNING "It takes too much time to run test in DEBUG mode, some tests are skipped")
diff --git a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
index 4e59c2f11e..1a413dc457 100644
--- a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
+++ b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
@@ -310,10 +310,10 @@ namespace NKikimr {
     bool TSyncerData::CheckCompatibility(TString& errorReason) {
         if (StoredCompatibilityInfo) {
             return TCompatibilityInfo::CheckCompatibility(&*StoredCompatibilityInfo,
-                    (ui32)NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
+                    NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
         } else {
             return TCompatibilityInfo::CheckCompatibility(nullptr,
-                    (ui32)NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
+                    NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
         }
     }
 
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
index 3b26d05d55..5836e35379 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -786,18 +786,19 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
                 CheckVersionTag();
 
                 icCommon->CompatibilityInfo = TString();
-                Y_VERIFY(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo));
+                bool success = TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo);
+                Y_VERIFY(success);
                 icCommon->ValidateCompatibilityInfo = [&](const TString& peer, TString& errorReason) {
                     NKikimrConfig::TStoredCompatibilityInfo peerPB;
                     if (!peerPB.ParseFromString(peer)) {
                         errorReason = "Cannot parse given CompatibilityInfo";
                         return false;
                     }
-                    return TCompatibilityInfo::CheckCompatibility(&peerPB, (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    return TCompatibilityInfo::CheckCompatibility(&peerPB, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
 
                 icCommon->ValidateCompatibilityOldFormat = [&](const NActors::TInterconnectProxyCommon::TVersionInfo& peer, TString& errorReason) {
-                    return TCompatibilityInfo::CheckCompatibility(peer, (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    return TCompatibilityInfo::CheckCompatibility(peer, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
             }
 
diff --git a/ydb/core/driver_lib/run/run.cpp b/ydb/core/driver_lib/run/run.cpp
index a2f29d7a98..106a41dd3a 100644
--- a/ydb/core/driver_lib/run/run.cpp
+++ b/ydb/core/driver_lib/run/run.cpp
@@ -31,6 +31,7 @@
 #include <library/cpp/actors/protos/services_common.pb.h>
 #include <ydb/core/cms/console/grpc_library_helper.h>
 #include <ydb/core/keyvalue/keyvalue.h>
+#include <ydb/core/driver_lib/version/version.h>
 #include <ydb/core/formats/clickhouse_block.h>
 #include <ydb/core/grpc_services/grpc_request_proxy.h>
 #include <ydb/core/grpc_services/grpc_mon.h>
@@ -1808,6 +1809,7 @@ void TKikimrRunner::InitializeRegistries(const TKikimrRunConfig& runConfig) {
 TIntrusivePtr<TKikimrRunner> TKikimrRunner::CreateKikimrRunner(
         const TKikimrRunConfig& runConfig,
         std::shared_ptr<TModuleFactories> factories) {
+    TCompatibilityInfo::Initialize();
 
     TIntrusivePtr<TKikimrRunner> runner(new TKikimrRunner(factories));
     runner->InitializeAllocator(runConfig);
diff --git a/ydb/core/driver_lib/version/ut/version_ut.cpp b/ydb/core/driver_lib/version/ut/version_ut.cpp
index d37e56b964..77c13bf29f 100644
--- a/ydb/core/driver_lib/version/ut/version_ut.cpp
+++ b/ydb/core/driver_lib/version/ut/version_ut.cpp
@@ -24,12 +24,13 @@ using TStoredCompatibilityInfo = TCompatibilityInfo::TProtoConstructor::TStoredC
 Y_UNIT_TEST_SUITE(YdbVersion) {
 
     void Test(TCurrentCompatibilityInfo current, TCurrentCompatibilityInfo store, bool expected) {
+        TCompatibilityInfo::Initialize();
         TString errorReason;
         auto currentPB = current.ToPB();
         auto storePB = store.ToPB();
-        auto storedPB = TCompatibilityInfo::MakeStored((ui32)NKikimrConfig::TCompatibilityRule::Test1, &storePB);
+        auto storedPB = TCompatibilityInfo::MakeStored(EComponentId::Test1, &storePB);
         UNIT_ASSERT_EQUAL_C(TCompatibilityInfo::CheckCompatibility(&currentPB, &storedPB, 
-            (ui32)EComponentId::Test1, errorReason), expected, errorReason);
+            EComponentId::Test1, errorReason), expected, errorReason);
     }
 
     Y_UNIT_TEST(DefaultSameVersion) {
@@ -589,10 +590,11 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
 
 Y_UNIT_TEST_SUITE(OldFormat) {
     void TestOldFormat(TCurrentCompatibilityInfo current, TOldFormat stored, bool expected) {
+        TCompatibilityInfo::Initialize();
         TString errorReason;
         auto currentPB = current.ToPB();
         UNIT_ASSERT_EQUAL_C(TCompatibilityInfo::CheckCompatibility(&currentPB, stored, 
-            (ui32)EComponentId::Interconnect, errorReason), expected, errorReason);
+            EComponentId::Interconnect, errorReason), expected, errorReason);
     }
 
     Y_UNIT_TEST(SameVersion) {
diff --git a/ydb/core/driver_lib/version/version.cpp b/ydb/core/driver_lib/version/version.cpp
index f15616302d..ad5466de0e 100644
--- a/ydb/core/driver_lib/version/version.cpp
+++ b/ydb/core/driver_lib/version/version.cpp
@@ -3,39 +3,66 @@
 #include <ydb/library/yverify_stream/yverify_stream.h>
 #include "version.h"
 
+namespace NKikimr {
+
 using TCurrent = NKikimrConfig::TCurrentCompatibilityInfo;
 using TStored = NKikimrConfig::TStoredCompatibilityInfo;
 using TOldFormat = NActors::TInterconnectProxyCommon::TVersionInfo;
 
-namespace NKikimr {
+using EComponentId = NKikimrConfig::TCompatibilityRule;
+using TComponentId = NKikimrConfig::TCompatibilityRule::EComponentId;
 
 /////////////////////////////////////////////////////////////
 // Global definitions
 /////////////////////////////////////////////////////////////
+TCurrent TCompatibilityInfo::CompatibilityInfo = {};
+TCompatibilityInfo::TDefaultCompatibilityInfo TCompatibilityInfo::DefaultCompatibilityInfo = {};
 
 // new version control
-std::optional<TCurrent> TCompatibilityInfo::CompatibilityInfo = std::nullopt;
-TSpinLock TCompatibilityInfo::LockCurrent = TSpinLock();
-const TCurrent* TCompatibilityInfo::GetCurrent() {
-    TGuard<TSpinLock> g(TCompatibilityInfo::LockCurrent);
-
-    if (!CompatibilityInfo) {
-        // using TYdbVersion = TCompatibilityInfo::TProtoConstructor::TYdbVersion;
-        // using TCompatibilityRule = TCompatibilityInfo::TProtoConstructor::TCompatibilityRule;
-        using TCurrentCompatibilityInfo = TCompatibilityInfo::TProtoConstructor::TCurrentCompatibilityInfo;
-
-        auto current = TCurrentCompatibilityInfo{
-            .Build = "trunk"
-        }.ToPB();
-
-        // bool success = CompleteFromTag(current);
-        // Y_VERIFY_DEBUG(success);
-
-        CompatibilityInfo = TCurrent();
-        CompatibilityInfo->CopyFrom(current);
-    }
-
-    return &*CompatibilityInfo;
+void TCompatibilityInfo::Initialize() {
+    /////////////////////////////////////////////////////////
+    // Current CompatibilityInfo
+    /////////////////////////////////////////////////////////
+
+    using TCurrentConstructor = TCompatibilityInfo::TProtoConstructor::TCurrentCompatibilityInfo;
+    using TStoredConstructor = TCompatibilityInfo::TProtoConstructor::TStoredCompatibilityInfo;
+    using TYdbVersion = TCompatibilityInfo::TProtoConstructor::TYdbVersion;
+
+    auto current = TCurrentConstructor{
+        .Build = "trunk"
+    }.ToPB();
+
+    // bool success = CompleteFromTag(current);
+    // Y_VERIFY_DEBUG(success);
+
+    CompatibilityInfo.CopyFrom(current);
+
+    /////////////////////////////////////////////////////////
+    // Default CompatibilityInfo
+    /////////////////////////////////////////////////////////
+
+#define EMPLACE_DEFAULT_INFO(componentName, build, year, major, minor, hotfix)              \
+    {                                                                                       \
+        auto& defaultInfo = DefaultCompatibilityInfo[(ui32)EComponentId::componentName];    \
+        defaultInfo.emplace();                                                              \
+        defaultInfo->CopyFrom(                                                              \
+            TStoredConstructor{                                                             \
+                .Build = build,                                                             \
+                .YdbVersion = TYdbVersion{                                                  \
+                    .Year = year,                                                           \
+                    .Major = major,                                                         \
+                    .Minor = minor,                                                         \
+                    .Hotfix = hotfix,                                                       \
+                },                                                                          \
+            }.ToPB()                                                                        \
+        );                                                                                  \
+    }
+
+//  EMPLACE_DEFAULT_INFO(PDisk, "ydb", ?, ?, ?, ?) TODO
+    EMPLACE_DEFAULT_INFO(VDisk, "ydb", 23, 2, 10, 0)
+//  EMPLACE_DEFAULT_INFO(BlobStorageController, "ydb", ?, ?, ?, ?) TODO
+
+#undef EMPLACE_DEFAULT_INFO
 }
 
 // obsolete version control
@@ -50,32 +77,21 @@ TMaybe<NActors::TInterconnectProxyCommon::TVersionInfo> VERSION = NActors::TInte
     }
 };
 
+const TCurrent* TCompatibilityInfo::GetCurrent() {
+    return &CompatibilityInfo;
+}
+
 /////////////////////////////////////////////////////////////
 // Implementation
 /////////////////////////////////////////////////////////////
-
 // Last stable YDB release, which doesn't include version control change
 // When the compatibility information is not present in component's data,
 // we assume component's version to be this version
-std::optional<TStored> TCompatibilityInfo::UnknownYdbRelease = std::nullopt;
-const TStored* TCompatibilityInfo::GetUnknown() {
-    static TSpinLock lock;
-    TGuard<TSpinLock> g(lock);
-
-    if (!UnknownYdbRelease) {
-        using TYdbVersion = TCompatibilityInfo::TProtoConstructor::TYdbVersion;
-        // using TCompatibilityRule = TCompatibilityInfo::TProtoConstructor::TCompatibilityRule;
-        using TStoredCompatibilityInfo = TCompatibilityInfo::TProtoConstructor::TStoredCompatibilityInfo;
-
-        UnknownYdbRelease = TStored();
-        UnknownYdbRelease->CopyFrom(TStoredCompatibilityInfo{
-            .Build = "ydb",
-            .YdbVersion = TYdbVersion{ .Year = 22, .Major = 5, .Minor = 7, .Hotfix = 0 }
-
-        }.ToPB());
-    }
-
-    return &*UnknownYdbRelease;
+const TStored* TCompatibilityInfo::GetDefault(TComponentId componentId) {
+    const auto& compatibilityInfo = DefaultCompatibilityInfo[(ui32)componentId];
+    Y_VERIFY_S(compatibilityInfo, "Default version is not defined for component# " <<
+            NKikimrConfig::TCompatibilityRule::EComponentId_Name(componentId));
+    return &*compatibilityInfo;
 }
 
 // Auxiliary output functions
@@ -103,7 +119,7 @@ TString PrintStoredAndCurrent(const TOldFormat& stored, const TCurrent* current)
     return str.Str();
 }
 
-TStored TCompatibilityInfo::MakeStored(ui32 componentId, const TCurrent* current) {
+TStored TCompatibilityInfo::MakeStored(TComponentId componentId, const TCurrent* current) {
     Y_VERIFY(current);
 
     TStored stored;
@@ -114,8 +130,8 @@ TStored TCompatibilityInfo::MakeStored(ui32 componentId, const TCurrent* current
 
     for (ui32 i = 0; i < current->StoresReadableBySize(); i++) {
         auto rule = current->GetStoresReadableBy(i);
-        if (!rule.HasComponentId() || rule.GetComponentId() == componentId ||
-                rule.GetComponentId() == (ui32)NKikimrConfig::TCompatibilityRule::Any) {
+        const auto ruleComponentId = TComponentId(rule.GetComponentId());
+        if (!rule.HasComponentId() || ruleComponentId == componentId || ruleComponentId == EComponentId::Any) {
             auto *newRule = stored.AddReadableBy();
             if (rule.HasBuild()) {
                 newRule->SetBuild(rule.GetBuild());
@@ -129,8 +145,8 @@ TStored TCompatibilityInfo::MakeStored(ui32 componentId, const TCurrent* current
     return stored;
 }
 
-TStored TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::EComponentId componentId) {
-    return MakeStored((ui32)componentId, GetCurrent());
+TStored TCompatibilityInfo::MakeStored(TComponentId componentId) {
+    return MakeStored(componentId, GetCurrent());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -187,18 +203,19 @@ i32 CompareVersions(const NKikimrConfig::TYdbVersion& left, const NKikimrConfig:
 }
 
 // If stored CompatibilityInfo is not present, we:
-// - compare current to UnknownYdbRelease if current is stable version
+// - compare current to DefaultCompatibilityInfo if current is stable version
 // - consider versions compatible otherwise
-bool CheckNonPresent(const TCurrent* current, ui32 componentId, TString& errorReason) {
+bool CheckNonPresent(const TCurrent* current, TComponentId componentId, TString& errorReason) {
     Y_VERIFY(current);
     if (!current->HasYdbVersion()) {
         return true;
     }
-    const auto* lastUnsupported = TCompatibilityInfo::GetUnknown();
+    const auto* lastUnsupported = TCompatibilityInfo::GetDefault(componentId);
     Y_VERIFY(lastUnsupported);
+
     TString errorReason1;
     if (!TCompatibilityInfo::CheckCompatibility(lastUnsupported, componentId, errorReason1)) {
-        errorReason = "No stored YDB version found, last unsupported release is incompatible: " + errorReason1;
+        errorReason = "No stored YDB version found, default version is incompatible: " + errorReason1;
         return false;
     } else {
         return true;
@@ -258,7 +275,7 @@ bool CheckRule(std::optional<TString> build, const NKikimrConfig::TYdbVersion* v
             (!rule.HasUpperLimit() || CompareVersions(*version, rule.GetUpperLimit()) < 1);
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStored* stored, ui32 componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStored* stored, TComponentId componentId, TString& errorReason) {
     Y_VERIFY(current);
     if (stored == nullptr) {
         // version record is not found
@@ -275,8 +292,8 @@ bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStor
 
     for (ui32 i = 0; i < current->CanLoadFromSize(); ++i) {
         const auto rule = current->GetCanLoadFrom(i);
-        if (!rule.HasComponentId() || rule.GetComponentId() == componentId ||
-                rule.GetComponentId() == (ui32)NKikimrConfig::TCompatibilityRule::Any) {
+        const auto ruleComponentId = TComponentId(rule.GetComponentId());
+        if (!rule.HasComponentId() || ruleComponentId == componentId || ruleComponentId == EComponentId::Any) {
             useDefault = false;
             if (CheckRule(storedBuild, storedYdbVersion, rule)) {
                 if (rule.HasForbidden() && rule.GetForbidden()) {
@@ -291,8 +308,8 @@ bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStor
 
     for (ui32 i = 0; i < stored->ReadableBySize(); ++i) {
         const auto rule = stored->GetReadableBy(i);
-        if (!rule.HasComponentId() || rule.GetComponentId() == componentId ||
-                rule.GetComponentId() == (ui32)NKikimrConfig::TCompatibilityRule::Any) {
+        const auto ruleComponentId = TComponentId(rule.GetComponentId());
+        if (!rule.HasComponentId() || ruleComponentId == componentId || ruleComponentId == EComponentId::Any) {
             if (CheckRule(currentBuild, currentYdbVersion, rule)) {
                 useDefault = false;
                 if (rule.HasForbidden() && rule.GetForbidden()) {
@@ -321,16 +338,12 @@ bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStor
     }
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TStored* stored, ui32 componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TStored* stored, TComponentId componentId, TString& errorReason) {
     return CheckCompatibility(GetCurrent(), stored, componentId, errorReason);
 }
 
 void TCompatibilityInfo::Reset(TCurrent* newCurrent) {
-    TGuard<TSpinLock> g(TCompatibilityInfo::LockCurrent);
-    if (!CompatibilityInfo) {
-        CompatibilityInfo = TCurrent();
-    }
-    CompatibilityInfo->CopyFrom(*newCurrent);
+    CompatibilityInfo.CopyFrom(*newCurrent);
 }
 
 TString GetBranchName(TString url) {
@@ -543,8 +556,7 @@ void CheckVersionTag() {
     }
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
-        const TOldFormat& stored, ui32 componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TOldFormat& stored, TComponentId componentId, TString& errorReason) {
     Y_VERIFY(current);
 
     std::optional<TString> storedBuild;
@@ -563,8 +575,8 @@ bool TCompatibilityInfo::CheckCompatibility(const NKikimrConfig::TCurrentCompati
 
     for (ui32 i = 0; i < current->CanLoadFromSize(); ++i) {
         const auto rule = current->GetCanLoadFrom(i);
-        if (!rule.HasComponentId() || rule.GetComponentId() == componentId ||
-                rule.GetComponentId() == (ui32)NKikimrConfig::TCompatibilityRule::Any) {
+        const auto ruleComponentId = TComponentId(rule.GetComponentId());
+        if (!rule.HasComponentId() || ruleComponentId == componentId || ruleComponentId == EComponentId::Any) {
             if (!rule.HasBuild()) {
                 useDefault = false;
             }
@@ -641,7 +653,7 @@ bool TCompatibilityInfo::CheckCompatibility(const NKikimrConfig::TCurrentCompati
     return false;
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TOldFormat& stored, ui32 componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason) {
     return CheckCompatibility(GetCurrent(), stored, componentId, errorReason);
 }
 
diff --git a/ydb/core/driver_lib/version/version.h b/ydb/core/driver_lib/version/version.h
index cefb68ca00..e483518526 100644
--- a/ydb/core/driver_lib/version/version.h
+++ b/ydb/core/driver_lib/version/version.h
@@ -8,6 +8,7 @@ namespace NKikimr {
 class TCompatibilityInfo {
     friend class TCompatibilityInfoTest;
     using TOldFormat = NActors::TInterconnectProxyCommon::TVersionInfo;
+    using TComponentId = NKikimrConfig::TCompatibilityRule::EComponentId;
 
 public:
     struct TProtoConstructor {
@@ -117,32 +118,37 @@ public:
 
 public:
     TCompatibilityInfo() = delete;
-    static const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrent();
-    static const NKikimrConfig::TStoredCompatibilityInfo* GetUnknown();
 
-    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(NKikimrConfig::TCompatibilityRule::EComponentId componentId);
+    static void Initialize();
+    static const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrent();
+    static const NKikimrConfig::TStoredCompatibilityInfo* GetDefault(TComponentId componentId);
 
     // pass nullptr if stored CompatibilityInfo is absent
     static bool CheckCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
-            ui32 componentId, TString& errorReason);
+            TComponentId componentId, TString& errorReason);
     static bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
-            const NKikimrConfig::TStoredCompatibilityInfo* stored, ui32 componentId, TString& errorReason);
+            const NKikimrConfig::TStoredCompatibilityInfo* stored, TComponentId componentId,
+            TString& errorReason);
 
-    static bool CheckCompatibility(const TOldFormat& stored, ui32 componentId, TString& errorReason);
+    static bool CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason);
     static bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
-            const TOldFormat& stored, ui32 componentId, TString& errorReason);
+            const TOldFormat& stored, TComponentId componentId, TString& errorReason);
 
     static bool CompleteFromTag(NKikimrConfig::TCurrentCompatibilityInfo& current);
 
-    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(ui32 componentId,
+    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId);
+    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId,
             const NKikimrConfig::TCurrentCompatibilityInfo* current);
 
 private:
-    static TSpinLock LockCurrent;
-    static std::optional<NKikimrConfig::TCurrentCompatibilityInfo> CompatibilityInfo;
-    static std::optional<NKikimrConfig::TStoredCompatibilityInfo> UnknownYdbRelease;
+    static NKikimrConfig::TCurrentCompatibilityInfo CompatibilityInfo;
+
+    using TDefaultCompatibilityInfo = std::array<std::optional<NKikimrConfig::TStoredCompatibilityInfo>,
+            NKikimrConfig::TCompatibilityRule::ComponentsCount>;
+    static TDefaultCompatibilityInfo DefaultCompatibilityInfo;
 
     // functions that modify compatibility information are only accessible from friend classes
+    // Reset() is not thread-safe!
     static void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent);
 };
 
diff --git a/ydb/core/protos/config.proto b/ydb/core/protos/config.proto
index eac8cbfed3..dac6cd5329 100644
--- a/ydb/core/protos/config.proto
+++ b/ydb/core/protos/config.proto
@@ -1956,6 +1956,7 @@ message TCompatibilityRule {
         PDisk = 4;
         VDisk = 5;
         BlobStorageController = 6;
+        ComponentsCount = 7;
     }
 
     optional string Build = 1;