Initialize CompatibilityInfo variables statically, KIKIMR-18776

Initialize CompatibilityInfo variables on demand

9 files changed, 88 insertions, 99 deletions

diff --git a/ydb/core/actorlib_impl/test_interconnect_ut.cpp b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
index 854c668c21a..99fb703ff3f 100644
--- a/ydb/core/actorlib_impl/test_interconnect_ut.cpp
+++ b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
@@ -715,7 +715,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                 current = node1.get();
             }
             Y_VERIFY(current);
-            Y_VERIFY(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect, current)
+            Y_VERIFY(CompatibilityInfo.MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect, current)
                     .SerializeToString(&*common->CompatibilityInfo));
 
             common->ValidateCompatibilityInfo =
@@ -726,7 +726,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                         return false;
                     }
 
-                    return TCompatibilityInfo::CheckCompatibility(current, &peerPB,
+                    return CompatibilityInfo.CheckCompatibility(current, &peerPB,
                         NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
         });
@@ -823,7 +823,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                                 return false;
                             }
 
-                            return TCompatibilityInfo::CheckCompatibility(node0.get(), &peerPB,
+                            return CompatibilityInfo.CheckCompatibility(node0.get(), &peerPB,
                                 NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                         };
 
@@ -832,7 +832,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
                             if (!peer) {
                                 return true;
                             }
-                            return TCompatibilityInfo::CheckCompatibility(node0.get(), *peer,
+                            return CompatibilityInfo.CheckCompatibility(node0.get(), *peer,
                                 NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                         };
 
diff --git a/ydb/core/blobstorage/ut_blobstorage/recovery.cpp b/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
index efb4607bfa1..e9b55e0ef6e 100644
--- a/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
+++ b/ydb/core/blobstorage/ut_blobstorage/recovery.cpp
@@ -64,7 +64,6 @@ Y_UNIT_TEST_SUITE(CompatibilityInfo) {
         auto oldInfo = oldInfoConstructor.ToPB();
         auto newInfo = newInfoConstructor.ToPB();
 
-        TCompatibilityInfo::Initialize();
         TCompatibilityInfoTest::Reset(&oldInfo);
 
         TEnvironmentSetup env{{
diff --git a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
index 1a413dc4576..f545cee45ce 100644
--- a/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
+++ b/ydb/core/blobstorage/vdisk/syncer/blobstorage_syncer_data.cpp
@@ -309,10 +309,10 @@ namespace NKikimr {
 
     bool TSyncerData::CheckCompatibility(TString& errorReason) {
         if (StoredCompatibilityInfo) {
-            return TCompatibilityInfo::CheckCompatibility(&*StoredCompatibilityInfo,
+            return CompatibilityInfo.CheckCompatibility(&*StoredCompatibilityInfo,
                     NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
         } else {
-            return TCompatibilityInfo::CheckCompatibility(nullptr,
+            return CompatibilityInfo.CheckCompatibility(nullptr,
                     NKikimrConfig::TCompatibilityRule::VDisk, errorReason);
         }
     }
@@ -328,7 +328,7 @@ namespace NKikimr {
                                                   top))
         , LocalSyncerState()
         , NotifyId(notifyId)
-        , CurrentCompatibilityInfo(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::VDisk))
+        , CurrentCompatibilityInfo(CompatibilityInfo.MakeStored(NKikimrConfig::TCompatibilityRule::VDisk))
     {
         TString serProto = WithoutSignature(Convert(selfVDisk, top, entryPoint));
         ParseWOSignature(serProto);
@@ -345,7 +345,7 @@ namespace NKikimr {
                                                   top))
         , LocalSyncerState()
         , NotifyId(notifyId)
-        , CurrentCompatibilityInfo(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::VDisk))
+        , CurrentCompatibilityInfo(CompatibilityInfo.MakeStored(NKikimrConfig::TCompatibilityRule::VDisk))
     {
         TString serProto = WithoutSignature(Convert(selfVDisk, top, entryPoint));
         ParseWOSignature(serProto);
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
index 9857c6fbb5c..d219a75f16d 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -787,7 +787,7 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
                 CheckVersionTag();
 
                 icCommon->CompatibilityInfo = TString();
-                bool success = TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo);
+                bool success = CompatibilityInfo.MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo);
                 Y_VERIFY(success);
                 icCommon->ValidateCompatibilityInfo = [&](const TString& peer, TString& errorReason) {
                     NKikimrConfig::TStoredCompatibilityInfo peerPB;
@@ -795,11 +795,11 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
                         errorReason = "Cannot parse given CompatibilityInfo";
                         return false;
                     }
-                    return TCompatibilityInfo::CheckCompatibility(&peerPB, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    return CompatibilityInfo.CheckCompatibility(&peerPB, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
 
                 icCommon->ValidateCompatibilityOldFormat = [&](const NActors::TInterconnectProxyCommon::TVersionInfo& peer, TString& errorReason) {
-                    return TCompatibilityInfo::CheckCompatibility(peer, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    return CompatibilityInfo.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 3e8a0e31884..444191ea8b4 100644
--- a/ydb/core/driver_lib/run/run.cpp
+++ b/ydb/core/driver_lib/run/run.cpp
@@ -31,7 +31,6 @@
 #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>
@@ -1837,8 +1836,6 @@ 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);
     runner->InitializeRegistries(runConfig);
diff --git a/ydb/core/driver_lib/version/ut/ut_helpers.h b/ydb/core/driver_lib/version/ut/ut_helpers.h
index f66aadb6c8e..47aea039b7d 100644
--- a/ydb/core/driver_lib/version/ut/ut_helpers.h
+++ b/ydb/core/driver_lib/version/ut/ut_helpers.h
@@ -7,7 +7,7 @@ public:
     TCompatibilityInfoTest() = delete;
 
     static void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent) {
-        TCompatibilityInfo::Reset(newCurrent);
+        CompatibilityInfo.Reset(newCurrent);
     }
 };
 
diff --git a/ydb/core/driver_lib/version/ut/version_ut.cpp b/ydb/core/driver_lib/version/ut/version_ut.cpp
index 77c13bf29f8..eceda543acd 100644
--- a/ydb/core/driver_lib/version/ut/version_ut.cpp
+++ b/ydb/core/driver_lib/version/ut/version_ut.cpp
@@ -24,12 +24,11 @@ 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(EComponentId::Test1, &storePB);
-        UNIT_ASSERT_EQUAL_C(TCompatibilityInfo::CheckCompatibility(&currentPB, &storedPB, 
+        auto storedPB = CompatibilityInfo.MakeStored(EComponentId::Test1, &storePB);
+        UNIT_ASSERT_EQUAL_C(CompatibilityInfo.CheckCompatibility(&currentPB, &storedPB, 
             EComponentId::Test1, errorReason), expected, errorReason);
     }
 
@@ -576,24 +575,23 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
     }
 
     Y_UNIT_TEST(CompatibleWithSelf) {
-        auto stored = TCompatibilityInfo::MakeStored(EComponentId::Test1);
+        auto stored = CompatibilityInfo.MakeStored(EComponentId::Test1);
         TString errorReason;
-        UNIT_ASSERT_C(TCompatibilityInfo::CheckCompatibility(&stored, EComponentId::Test1, errorReason), errorReason);
+        UNIT_ASSERT_C(CompatibilityInfo.CheckCompatibility(&stored, EComponentId::Test1, errorReason), errorReason);
     }
 
     Y_UNIT_TEST(PrintCurrentVersion) {
         TString str;
-        google::protobuf::TextFormat::PrintToString(*TCompatibilityInfo::GetCurrent(), &str);
+        google::protobuf::TextFormat::PrintToString(*CompatibilityInfo.GetCurrent(), &str);
         Cerr << str << Endl;
     }
 }
 
 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, 
+        UNIT_ASSERT_EQUAL_C(CompatibilityInfo.CheckCompatibility(&currentPB, stored, 
             EComponentId::Interconnect, errorReason), expected, errorReason);
     }
 
diff --git a/ydb/core/driver_lib/version/version.cpp b/ydb/core/driver_lib/version/version.cpp
index ad5466de0e9..1c8056066f3 100644
--- a/ydb/core/driver_lib/version/version.cpp
+++ b/ydb/core/driver_lib/version/version.cpp
@@ -5,6 +5,8 @@
 
 namespace NKikimr {
 
+TCompatibilityInfo CompatibilityInfo = TCompatibilityInfo{};
+
 using TCurrent = NKikimrConfig::TCurrentCompatibilityInfo;
 using TStored = NKikimrConfig::TStoredCompatibilityInfo;
 using TOldFormat = NActors::TInterconnectProxyCommon::TVersionInfo;
@@ -12,22 +14,14 @@ using TOldFormat = NActors::TInterconnectProxyCommon::TVersionInfo;
 using EComponentId = NKikimrConfig::TCompatibilityRule;
 using TComponentId = NKikimrConfig::TCompatibilityRule::EComponentId;
 
-/////////////////////////////////////////////////////////////
-// Global definitions
-/////////////////////////////////////////////////////////////
-TCurrent TCompatibilityInfo::CompatibilityInfo = {};
-TCompatibilityInfo::TDefaultCompatibilityInfo TCompatibilityInfo::DefaultCompatibilityInfo = {};
+TCompatibilityInfo::TCompatibilityInfo() {
+    using TCurrentConstructor = TCompatibilityInfo::TProtoConstructor::TCurrentCompatibilityInfo;
+    using TStoredConstructor = TCompatibilityInfo::TProtoConstructor::TStoredCompatibilityInfo;
+    using TYdbVersionConstructor = TCompatibilityInfo::TProtoConstructor::TYdbVersion;
 
-// new version control
-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();
@@ -35,34 +29,42 @@ void TCompatibilityInfo::Initialize() {
     // bool success = CompleteFromTag(current);
     // Y_VERIFY_DEBUG(success);
 
-    CompatibilityInfo.CopyFrom(current);
+    CurrentCompatibilityInfo.CopyFrom(current);
 
     /////////////////////////////////////////////////////////
     // Default CompatibilityInfo
     /////////////////////////////////////////////////////////
+    DefaultCompatibilityInfo = TDefaultCompatibilityInfo{};
+#define EMPLACE_DEFAULT_COMPATIBILITY_INFO(componentName, build, year, major, minor, hotfix)    \
+    auto& defaultInfo = DefaultCompatibilityInfo[(ui32)EComponentId::componentName];            \
+    defaultInfo.emplace();                                                                      \
+    defaultInfo->CopyFrom(                                                                      \
+        TStoredConstructor{                                                                     \
+            .Build = build,                                                                     \
+            .YdbVersion = TYdbVersionConstructor{                                               \
+                .Year = year,                                                                   \
+                .Major = major,                                                                 \
+                .Minor = minor,                                                                 \
+                .Hotfix = hotfix,                                                               \
+            },                                                                                  \
+        }.ToPB()                                                                                \
+    );
+
+//  EMPLACE_DEFAULT_COMPATIBILITY_INFO(PDisk, "ydb", ?, ?, ?, ?) TODO
+    EMPLACE_DEFAULT_COMPATIBILITY_INFO(VDisk, "ydb", 23, 2, 12, 0)
+//  EMPLACE_DEFAULT_COMPATIBILITY_INFO(BlobStorageController, "ydb", ?, ?, ?, ?) TODO
+
+#undef EMPLACE_DEFAULT_COMPATIBILITY_INFO
+}
+
+const TCurrent* TCompatibilityInfo::GetCurrent() const {
+    return &CurrentCompatibilityInfo;
+}
 
-#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
+const TStored* TCompatibilityInfo::GetDefault(TComponentId componentId) const {
+    const auto& info = DefaultCompatibilityInfo[componentId];
+    Y_VERIFY_S(info, "Default version is not defined for component# " << NKikimrConfig::TCompatibilityRule::EComponentId_Name(componentId));
+    return &*info;
 }
 
 // obsolete version control
@@ -77,22 +79,9 @@ 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
-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
 TString PrintStoredAndCurrent(const TStored* stored, const TCurrent* current) {
@@ -119,7 +108,7 @@ TString PrintStoredAndCurrent(const TOldFormat& stored, const TCurrent* current)
     return str.Str();
 }
 
-TStored TCompatibilityInfo::MakeStored(TComponentId componentId, const TCurrent* current) {
+TStored TCompatibilityInfo::MakeStored(TComponentId componentId, const TCurrent* current) const {
     Y_VERIFY(current);
 
     TStored stored;
@@ -145,7 +134,7 @@ TStored TCompatibilityInfo::MakeStored(TComponentId componentId, const TCurrent*
     return stored;
 }
 
-TStored TCompatibilityInfo::MakeStored(TComponentId componentId) {
+TStored TCompatibilityInfo::MakeStored(TComponentId componentId) const {
     return MakeStored(componentId, GetCurrent());
 }
 
@@ -210,11 +199,11 @@ bool CheckNonPresent(const TCurrent* current, TComponentId componentId, TString&
     if (!current->HasYdbVersion()) {
         return true;
     }
-    const auto* lastUnsupported = TCompatibilityInfo::GetDefault(componentId);
+    const auto* lastUnsupported = CompatibilityInfo.GetDefault(componentId);
     Y_VERIFY(lastUnsupported);
 
     TString errorReason1;
-    if (!TCompatibilityInfo::CheckCompatibility(lastUnsupported, componentId, errorReason1)) {
+    if (!CompatibilityInfo.CheckCompatibility(lastUnsupported, componentId, errorReason1)) {
         errorReason = "No stored YDB version found, default version is incompatible: " + errorReason1;
         return false;
     } else {
@@ -275,7 +264,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, TComponentId componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStored* stored, TComponentId componentId, TString& errorReason) const {
     Y_VERIFY(current);
     if (stored == nullptr) {
         // version record is not found
@@ -338,12 +327,12 @@ bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TStor
     }
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TStored* stored, TComponentId componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TStored* stored, TComponentId componentId, TString& errorReason) const {
     return CheckCompatibility(GetCurrent(), stored, componentId, errorReason);
 }
 
 void TCompatibilityInfo::Reset(TCurrent* newCurrent) {
-    CompatibilityInfo.CopyFrom(*newCurrent);
+    CurrentCompatibilityInfo.CopyFrom(*newCurrent);
 }
 
 TString GetBranchName(TString url) {
@@ -556,7 +545,7 @@ void CheckVersionTag() {
     }
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TOldFormat& stored, TComponentId componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TOldFormat& stored, TComponentId componentId, TString& errorReason) const {
     Y_VERIFY(current);
 
     std::optional<TString> storedBuild;
@@ -653,7 +642,7 @@ bool TCompatibilityInfo::CheckCompatibility(const TCurrent* current, const TOldF
     return false;
 }
 
-bool TCompatibilityInfo::CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason) {
+bool TCompatibilityInfo::CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason) const {
     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 e4835185265..3e83f9307c1 100644
--- a/ydb/core/driver_lib/version/version.h
+++ b/ydb/core/driver_lib/version/version.h
@@ -7,6 +7,8 @@ namespace NKikimr {
 
 class TCompatibilityInfo {
     friend class TCompatibilityInfoTest;
+    friend class TCompatibilityInfoInitializer;
+
     using TOldFormat = NActors::TInterconnectProxyCommon::TVersionInfo;
     using TComponentId = NKikimrConfig::TCompatibilityRule::EComponentId;
 
@@ -117,41 +119,45 @@ public:
     };
 
 public:
-    TCompatibilityInfo() = delete;
+    TCompatibilityInfo();
 
-    static void Initialize();
-    static const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrent();
-    static const NKikimrConfig::TStoredCompatibilityInfo* GetDefault(TComponentId componentId);
+    const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrent() const;
+    const NKikimrConfig::TStoredCompatibilityInfo* GetDefault(TComponentId componentId) const;
 
     // pass nullptr if stored CompatibilityInfo is absent
-    static bool CheckCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
-            TComponentId componentId, TString& errorReason);
-    static bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
+    bool CheckCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
+            TComponentId componentId, TString& errorReason) const;
+    bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
             const NKikimrConfig::TStoredCompatibilityInfo* stored, TComponentId componentId,
-            TString& errorReason);
+            TString& errorReason) const;
 
-    static bool CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason);
-    static bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
-            const TOldFormat& stored, TComponentId componentId, TString& errorReason);
+    bool CheckCompatibility(const TOldFormat& stored, TComponentId componentId, TString& errorReason) const;
+    bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
+            const TOldFormat& stored, TComponentId componentId, TString& errorReason) const;
 
-    static bool CompleteFromTag(NKikimrConfig::TCurrentCompatibilityInfo& current);
+    bool CompleteFromTag(NKikimrConfig::TCurrentCompatibilityInfo& current);
 
-    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId);
-    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId,
-            const NKikimrConfig::TCurrentCompatibilityInfo* current);
+    NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId) const;
+    NKikimrConfig::TStoredCompatibilityInfo MakeStored(TComponentId componentId,
+            const NKikimrConfig::TCurrentCompatibilityInfo* current) const;
 
 private:
-    static NKikimrConfig::TCurrentCompatibilityInfo CompatibilityInfo;
+    NKikimrConfig::TCurrentCompatibilityInfo CurrentCompatibilityInfo;
 
+    // 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
     using TDefaultCompatibilityInfo = std::array<std::optional<NKikimrConfig::TStoredCompatibilityInfo>,
             NKikimrConfig::TCompatibilityRule::ComponentsCount>;
-    static TDefaultCompatibilityInfo DefaultCompatibilityInfo;
+    TDefaultCompatibilityInfo DefaultCompatibilityInfo;
 
     // functions that modify compatibility information are only accessible from friend classes
     // Reset() is not thread-safe!
-    static void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent);
+    void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent);
 };
 
+extern TCompatibilityInfo CompatibilityInfo;
+
 // obsolete version control
 // TODO: remove in the next major release
 extern TMaybe<NActors::TInterconnectProxyCommon::TVersionInfo> VERSION;