Parse old IC version record, when new one is not present,

UT

initial

optional minor tag

Initial

4 files changed, 91 insertions, 2 deletions

diff --git a/library/cpp/actors/interconnect/interconnect_common.h b/library/cpp/actors/interconnect/interconnect_common.h
index 3364ca4cd97..64b707dc96f 100644
--- a/library/cpp/actors/interconnect/interconnect_common.h
+++ b/library/cpp/actors/interconnect/interconnect_common.h
@@ -106,6 +106,7 @@ namespace NActors {
 
         std::optional<TString> CompatibilityInfo;
         std::function<bool(const TString&, TString&)> ValidateCompatibilityInfo;
+        std::function<bool(const TInterconnectProxyCommon::TVersionInfo&, TString&)> ValidateCompatibilityOldFormat;
 
         using TPtr = TIntrusivePtr<TInterconnectProxyCommon>;
     };
diff --git a/library/cpp/actors/interconnect/interconnect_handshake.cpp b/library/cpp/actors/interconnect/interconnect_handshake.cpp
index df0ca29f2b9..cf1579bf8a1 100644
--- a/library/cpp/actors/interconnect/interconnect_handshake.cpp
+++ b/library/cpp/actors/interconnect/interconnect_handshake.cpp
@@ -291,13 +291,25 @@ namespace NActors {
         template<typename T, typename TCallback>
         void ValidateCompatibilityInfo(const T& proto, TCallback&& errorCallback) {
             // if possible, use new CompatibilityInfo field
-            if (Common->ValidateCompatibilityInfo && proto.HasCompatibilityInfo()) {
+            if (proto.HasCompatibilityInfo() && Common->ValidateCompatibilityInfo) {
                 TString errorReason;
                 if (!Common->ValidateCompatibilityInfo(proto.GetCompatibilityInfo(), errorReason)) {
                     TStringStream s("Local and peer CompatibilityInfo are incompatible");
                     s << ", errorReason# " << errorReason;
                     errorCallback(s.Str());
                 }
+            } else if (proto.HasVersionTag() && Common->ValidateCompatibilityOldFormat) {
+                TInterconnectProxyCommon::TVersionInfo oldFormat;
+                oldFormat.Tag = proto.GetVersionTag();
+                for (ui32 i = 0; i < proto.AcceptedVersionTagsSize(); ++i) {
+                    oldFormat.AcceptedTags.insert(proto.GetAcceptedVersionTags(i));
+                }
+                TString errorReason;
+                if (!Common->ValidateCompatibilityOldFormat(oldFormat, errorReason)) {
+                    TStringStream s("Local CompatibilityInfo and peer TVersionInfo are incompatible");
+                    s << ", errorReason# " << errorReason;
+                    errorCallback(s.Str());
+                }
             } else {
                 ValidateVersionTag(proto, std::forward<TCallback>(errorCallback));
             }
diff --git a/ydb/core/actorlib_impl/test_interconnect_ut.cpp b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
index 392ac4b5923..99e141c6aa1 100644
--- a/ydb/core/actorlib_impl/test_interconnect_ut.cpp
+++ b/ydb/core/actorlib_impl/test_interconnect_ut.cpp
@@ -709,7 +709,7 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         runtime.SetICCommonSetupper([&](ui32 nodeNum, TIntrusivePtr<TInterconnectProxyCommon> common) {
             common->CompatibilityInfo = TString();
             NKikimrConfig::TCurrentCompatibilityInfo* current = nullptr;
-            if (nodeNum == 0) {
+            if (nodeNum % 2 == 0) {
                 current = node0.get();
             } else if (nodeNum == 1) {
                 current = node1.get();
@@ -782,6 +782,78 @@ Y_UNIT_TEST_SUITE(TInterconnectTest) {
         TestConnectionWithDifferentVersions(node0, node1);
         TestConnectionWithDifferentVersions(node1, node0);
     }
+    
+    Y_UNIT_TEST(OldFormat) {
+        std::shared_ptr<NKikimrConfig::TCurrentCompatibilityInfo> node0 = 
+            std::make_shared<NKikimrConfig::TCurrentCompatibilityInfo>();
+        {
+            node0->SetBuild("ydb");
+            auto* version = node0->MutableYdbVersion();
+            version->SetYear(23);
+            version->SetMajor(1);
+            version->SetMinor(1);
+            version->SetHotfix(0);
+
+            {
+                auto* rule = node0->AddCanLoadFrom();
+                rule->SetComponentId((ui32)NKikimrConfig::TCompatibilityRule::Interconnect);
+
+                auto* bottomLimit = rule->MutableBottomLimit();
+                bottomLimit->SetYear(22);
+                bottomLimit->SetMajor(5);
+
+                rule->MutableUpperLimit()->CopyFrom(*version);
+
+                node0->AddStoresReadableBy()->CopyFrom(*rule);
+            }
+        }
+
+        TTestBasicRuntime runtime(2);
+        runtime.SetUseRealInterconnect();
+        runtime.SetICCommonSetupper([=](ui32 nodeNum, TIntrusivePtr<TInterconnectProxyCommon> common) {
+            if (nodeNum % 2 == 0) {
+                common->CompatibilityInfo = TString();
+
+                common->ValidateCompatibilityInfo = 
+                    [=](const TString& peer, TString& errorReason) {
+                        NKikimrConfig::TStoredCompatibilityInfo peerPB;
+                        if (!peerPB.ParseFromString(peer)) {
+                            errorReason = "Cannot parse given CompatibilityInfo";
+                            return false;
+                        }
+
+                        return TCompatibilityInfo::CheckCompatibility(node0.get(), &peerPB, 
+                            (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    };
+
+                common->ValidateCompatibilityOldFormat = 
+                    [=](const TMaybe<TInterconnectProxyCommon::TVersionInfo>& peer, TString& errorReason) {
+                        if (!peer) {
+                            return true;
+                        }
+                        return TCompatibilityInfo::CheckCompatibility(node0.get(), *peer, 
+                            (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                    }; 
+            } else {
+                common->VersionInfo = TInterconnectProxyCommon::TVersionInfo{
+                    .Tag = "stable-22-5-6-hotfix-1",
+                    .AcceptedTags = {"stable-22-5-6-hotfix-1"}
+                };
+            }
+        });
+
+        runtime.Initialize(TAppPrepare().Unwrap());
+
+        const auto edge = runtime.AllocateEdgeActor(0);
+        runtime.Send(new IEventHandle(runtime.GetInterconnectProxy(0, 1), edge, new TEvInterconnect::TEvConnectNode), 0, true);
+
+        TAutoPtr<IEventHandle> handle;
+        {
+            const auto event = runtime.GrabEdgeEvent<TEvInterconnect::TEvNodeConnected>(handle);
+            UNIT_ASSERT_EQUAL(event->NodeId, runtime.GetNodeId(1));
+        }
+    }
+    
 }
 
 }
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
index 99fdf43a857..678c64da0b1 100644
--- a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
+++ b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -770,6 +770,10 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
                     }
                     return TCompatibilityInfo::CheckCompatibility(&peerPB, (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
                 };
+
+                icCommon->ValidateCompatibilityOldFormat = [&](const NActors::TInterconnectProxyCommon::TVersionInfo& peer, TString& errorReason) {
+                    return TCompatibilityInfo::CheckCompatibility(peer, (ui32)NKikimrConfig::TCompatibilityRule::Interconnect, errorReason);
+                };
             }
 
             setup->LocalServices.emplace_back(GetDestructActorID(), TActorSetupCmd(new TDestructActor,