Wrap CompatibilityInfo functions in class,

Reset() function

Initial

4 files changed, 66 insertions, 38 deletions

diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
index cb3f00f6cf3..97e474e847e 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -760,14 +760,14 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
                 CheckVersionTag();
 
                 icCommon->CompatibilityInfo = TString();
-                Y_VERIFY(MakeStoredCompatibilityInfo((ui32)NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo));
+                Y_VERIFY(TCompatibilityInfo::MakeStored(NKikimrConfig::TCompatibilityRule::Interconnect).SerializeToString(&*icCommon->CompatibilityInfo));
                 icCommon->ValidateCompatibilityInfo = [&](const TString& peer, TString& errorReason) {
                     NKikimrConfig::TStoredCompatibilityInfo peerPB;
                     if (!peerPB.ParseFromString(peer)) {
                         errorReason = "Cannot parse given CompatibilityInfo";
                         return false;
                     }
-                    return CheckVersionCompatibility(&peerPB, NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    return TCompatibilityInfo::CheckCompatibility(&peerPB, (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
             }
 
diff --git a/ydb/core/driver_lib/run/version.cpp b/ydb/core/driver_lib/run/version.cpp
index 4e0c6849885..afb4688060a 100644
--- a/ydb/core/driver_lib/run/version.cpp
+++ b/ydb/core/driver_lib/run/version.cpp
@@ -1,12 +1,10 @@
 #include <library/cpp/svnversion/svnversion.h>
 #include "version.h"
 
-
-NKikimrConfig::TCurrentCompatibilityInfo* CompatibilityInfo = nullptr;
-
-const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrentCompatibilityInfo() {
-    static TSpinLock lock;
-    TGuard<TSpinLock> g(lock);
+NKikimrConfig::TCurrentCompatibilityInfo* TCompatibilityInfo::CompatibilityInfo = nullptr;
+TSpinLock TCompatibilityInfo::LockCurrent = TSpinLock();
+const NKikimrConfig::TCurrentCompatibilityInfo* TCompatibilityInfo::GetCurrent() {
+    TGuard<TSpinLock> g(TCompatibilityInfo::LockCurrent);
 
     if (!CompatibilityInfo) {
         CompatibilityInfo = new NKikimrConfig::TCurrentCompatibilityInfo();
@@ -21,8 +19,8 @@ const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrentCompatibilityInfo() {
 // 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
-NKikimrConfig::TStoredCompatibilityInfo* UnknownYdbRelease = nullptr;
-const NKikimrConfig::TStoredCompatibilityInfo* GetUnknownYdbRelease() {
+NKikimrConfig::TStoredCompatibilityInfo* TCompatibilityInfo::UnknownYdbRelease = nullptr;
+const NKikimrConfig::TStoredCompatibilityInfo* TCompatibilityInfo::GetUnknown() {
     static TSpinLock lock;
     TGuard<TSpinLock> g(lock);
 
@@ -40,8 +38,8 @@ const NKikimrConfig::TStoredCompatibilityInfo* GetUnknownYdbRelease() {
     return UnknownYdbRelease;
 }
 
-NKikimrConfig::TStoredCompatibilityInfo MakeStoredCompatibilityInfo(
-        ui32 componentId, const NKikimrConfig::TCurrentCompatibilityInfo* current) {
+NKikimrConfig::TStoredCompatibilityInfo TCompatibilityInfo::MakeStored(ui32 componentId,
+        const NKikimrConfig::TCurrentCompatibilityInfo* current) {
     Y_VERIFY(current);
 
     NKikimrConfig::TStoredCompatibilityInfo stored;
@@ -67,8 +65,9 @@ NKikimrConfig::TStoredCompatibilityInfo MakeStoredCompatibilityInfo(
     return stored;
 }
 
-NKikimrConfig::TStoredCompatibilityInfo MakeStoredCompatibilityInfo(ui32 componentId) {
-    return MakeStoredCompatibilityInfo(componentId, GetCurrentCompatibilityInfo());
+NKikimrConfig::TStoredCompatibilityInfo TCompatibilityInfo::MakeStored(
+        NKikimrConfig::TCompatibilityRule::EComponentId componentId) {
+    return MakeStored((ui32)componentId, GetCurrent());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////
@@ -132,10 +131,10 @@ bool CheckNonPresent(const NKikimrConfig::TCurrentCompatibilityInfo* current,
     if (!current->HasYdbVersion()) {
         return true;
     }
-    const auto* lastUnsupported = GetUnknownYdbRelease();
+    const auto* lastUnsupported = TCompatibilityInfo::GetUnknown();
     Y_VERIFY(lastUnsupported);
     TString errorReason1;
-    if (!CheckVersionCompatibility(current, lastUnsupported, componentId, errorReason1)) {
+    if (!TCompatibilityInfo::CheckCompatibility(current, lastUnsupported, componentId, errorReason1)) {
         errorReason = "No stored YDB version found, last unsupported release is incompatible: " + errorReason1;
         return false;
     } else {
@@ -185,7 +184,7 @@ bool CheckRule(TString build, const NKikimrConfig::TYdbVersion* version,
             (!rule.HasUpperLimit() || CompareVersions(*version, rule.GetUpperLimit()) < 1);
 }
 
-bool CheckVersionCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
+bool TCompatibilityInfo::CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
         const NKikimrConfig::TStoredCompatibilityInfo* stored, ui32 componentId, TString& errorReason) {
     if (stored == nullptr) {
         // version record is not found
@@ -249,12 +248,19 @@ bool CheckVersionCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* c
     }
 }
 
-bool CheckVersionCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
+bool TCompatibilityInfo::CheckCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
         ui32 componentId, TString& errorReason) {
-    return CheckVersionCompatibility(GetCurrentCompatibilityInfo(), 
-            stored, componentId, errorReason);
+    return CheckCompatibility(GetCurrent(), stored, componentId, errorReason);
 }
 
+void TCompatibilityInfo::Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent) {
+    TGuard<TSpinLock> g(TCompatibilityInfo::LockCurrent);
+    CompatibilityInfo = newCurrent;
+}
+
+void TCompatibilityInfoTest::Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent) {
+    TCompatibilityInfo::Reset(newCurrent);
+}
 // obsolete version control
 TMaybe<NActors::TInterconnectProxyCommon::TVersionInfo> VERSION = NActors::TInterconnectProxyCommon::TVersionInfo{
     // version of this binary
diff --git a/ydb/core/driver_lib/run/version.h b/ydb/core/driver_lib/run/version.h
index b44d7ff8aff..a5183a180d3 100644
--- a/ydb/core/driver_lib/run/version.h
+++ b/ydb/core/driver_lib/run/version.h
@@ -3,20 +3,43 @@
 #include <library/cpp/actors/interconnect/interconnect_common.h>
 #include <ydb/core/protos/config.pb.h>
 
-const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrentCompatibilityInfo();
-const NKikimrConfig::TStoredCompatibilityInfo* GetUnknownYdbRelease();
+class TCompatibilityInfoTest;
 
-NKikimrConfig::TStoredCompatibilityInfo MakeStoredCompatibilityInfo(ui32 componentId,
-        const NKikimrConfig::TCurrentCompatibilityInfo* current);
+class TCompatibilityInfo {
+    friend class TCompatibilityInfoTest;
 
-NKikimrConfig::TStoredCompatibilityInfo MakeStoredCompatibilityInfo(ui32 componentId);
+public:
+    TCompatibilityInfo() = delete;
+    static const NKikimrConfig::TCurrentCompatibilityInfo* GetCurrent();
+    static const NKikimrConfig::TStoredCompatibilityInfo* GetUnknown();
 
-bool CheckVersionCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
-        const NKikimrConfig::TStoredCompatibilityInfo* stored,
-        ui32 componentId, TString& errorReason);
+    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(NKikimrConfig::TCompatibilityRule::EComponentId componentId);
 
-bool CheckVersionCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
-        ui32 componentId, TString& errorReason);
+    static bool CheckCompatibility(const NKikimrConfig::TStoredCompatibilityInfo* stored,
+            ui32 componentId, TString& errorReason);
+
+    static bool CheckCompatibility(const NKikimrConfig::TCurrentCompatibilityInfo* current,
+            const NKikimrConfig::TStoredCompatibilityInfo* stored,
+            ui32 componentId, TString& errorReason);
+
+    static NKikimrConfig::TStoredCompatibilityInfo MakeStored(ui32 componentId,
+            const NKikimrConfig::TCurrentCompatibilityInfo* current);
+
+private:
+    static TSpinLock LockCurrent;
+    static NKikimrConfig::TCurrentCompatibilityInfo* CompatibilityInfo;
+    static NKikimrConfig::TStoredCompatibilityInfo* UnknownYdbRelease;
+
+    // functions that modify compatibility information are only accessible from friend classes
+    static void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent);
+};
+
+class TCompatibilityInfoTest {
+public:
+    TCompatibilityInfoTest() = delete;
+
+    static void Reset(NKikimrConfig::TCurrentCompatibilityInfo* newCurrent);
+};
 
 // obsolete version control
 // TODO: remove in the next major release
diff --git a/ydb/core/driver_lib/run/version_ut.cpp b/ydb/core/driver_lib/run/version_ut.cpp
index 6690a177cf3..89d4aadfb5f 100644
--- a/ydb/core/driver_lib/run/version_ut.cpp
+++ b/ydb/core/driver_lib/run/version_ut.cpp
@@ -11,6 +11,7 @@ Y_UNIT_TEST_SUITE(VersionParser) {
 }
 
 Y_UNIT_TEST_SUITE(YdbVersion) {
+    using EComponentId = NKikimrConfig::TCompatibilityRule;
     struct TYdbVersion {
         std::optional<ui32> Year;
         std::optional<ui32> Major;
@@ -113,8 +114,8 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
         TString errorReason;
         auto currentPB = current.ToPB();
         auto storePB = store.ToPB();
-        auto storedPB = MakeStoredCompatibilityInfo((ui32)NKikimrConfig::TCompatibilityRule::Test1, &storePB);
-        UNIT_ASSERT_EQUAL_C(CheckVersionCompatibility(&currentPB, &storedPB, 
+        auto storedPB = TCompatibilityInfo::MakeStored((ui32)NKikimrConfig::TCompatibilityRule::Test1, &storePB);
+        UNIT_ASSERT_EQUAL_C(TCompatibilityInfo::CheckCompatibility(&currentPB, &storedPB, 
             (ui32)NKikimrConfig::TCompatibilityRule::Test1, errorReason), expected, errorReason);
     }
 
@@ -593,7 +594,7 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
                         TCompatibilityRule{
                             .BottomLimit = TYdbVersion{ .Year = 1, .Major = 1 },
                             .UpperLimit = TYdbVersion{ .Year = 1, .Major = 4, .Minor = 2, .Hotfix = 0 },
-                            .ComponentId = (ui32)NKikimrConfig::TCompatibilityRule::Test1,
+                            .ComponentId = (ui32)EComponentId::Test1,
                         },
                     }
                 }, 
@@ -611,7 +612,7 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
                         TCompatibilityRule{
                             .BottomLimit = TYdbVersion{ .Year = 1, .Major = 1 },
                             .UpperLimit = TYdbVersion{ .Year = 1, .Major = 4, .Minor = 2, .Hotfix = 0 },
-                            .ComponentId = (ui32)NKikimrConfig::TCompatibilityRule::Test2,
+                            .ComponentId = (ui32)EComponentId::Test2,
                         },
                     }
                 }, 
@@ -623,10 +624,8 @@ Y_UNIT_TEST_SUITE(YdbVersion) {
     }
 
     Y_UNIT_TEST(CompatibleWithSelf) {
-        auto* current = GetCurrentCompatibilityInfo();
-        auto stored = MakeStoredCompatibilityInfo((ui32)NKikimrConfig::TCompatibilityRule::Test1);
+        auto stored = TCompatibilityInfo::MakeStored(EComponentId::Test1);
         TString errorReason;
-        UNIT_ASSERT_C(CheckVersionCompatibility(current, &stored, 
-                (ui32)NKikimrConfig::TCompatibilityRule::Test1, errorReason), errorReason);
+        UNIT_ASSERT_C(TCompatibilityInfo::CheckCompatibility(&stored, EComponentId::Test1, errorReason), errorReason);
     }
 }