make feature togglable

Author: yegorskii

cloud/blockstore/config/rdma.proto

@@ -14,6 +14,10 @@ message TRdmaTarget
     TRdmaEndpoint Endpoint = 1;
     NCloud.NProto.TRdmaServer Server = 2;   // deprecated
     uint32 WorkerThreads = 3;
+
+    // Keep track of the client connections and of the volumes mounted over
+    // them, and show them on a monitoring page.
+    bool ConnectionMonitoringEnabled = 4;
 }
 
 message TRdmaConfig

cloud/blockstore/libs/service_rdma/rdma_target.cpp

@@ -959,20 +959,23 @@ IStartablePtr CreateBlockstoreServerRdmaTarget(
     auto threadPool = CreateThreadPool("RDMA", rdmaTargetConfig->WorkerThreads);
     threadPool->Start();
 
-    // without a monitoring page there is nobody to read the connections, so
-    // the handler is left with an observer that drops them
-    auto mountRegistry = monitoring ? CreateMountRegistry(logging) : nullptr;
+    // without a page there is nobody to read the connections, so they are not
+    // tracked at all and the handler is left with an empty registry pointer
+    auto mountRegistry =
+        monitoring && rdmaTargetConfig->ConnectionMonitoringEnabled
+            ? CreateMountRegistry(logging)
+            : nullptr;
 
     auto target = std::make_shared<TRdmaTarget>(
         std::move(rdmaTargetConfig),
         std::move(logging),
         std::move(traceSerializer),
         std::move(server),
         std::move(threadPool),
-        std::move(mountRegistry),
+        mountRegistry,
         std::move(service));
 
-    if (monitoring) {
+    if (mountRegistry) {
         auto rootPage = monitoring->RegisterIndexPage("blockstore", "BlockStore");
         static_cast<TIndexMonPage&>(*rootPage).Register(
             new TRdmaTargetMonPage(target));

cloud/blockstore/libs/service_rdma/rdma_target.h

@@ -23,10 +23,13 @@ struct TBlockstoreServerRdmaTargetConfig
     TString Host = "localhost";
     ui32 Port = 10088;
     ui32 WorkerThreads = 1;
+    bool ConnectionMonitoringEnabled = false;
 
     explicit TBlockstoreServerRdmaTargetConfig(
         const NProto::TRdmaTarget& target)
     {
+        ConnectionMonitoringEnabled = target.GetConnectionMonitoringEnabled();
+
         const auto& endpoint = target.GetEndpoint();
 
         if (const auto& host = endpoint.GetHost()) {

cloud/blockstore/libs/service_rdma/rdma_target_ut.cpp

@@ -153,11 +153,15 @@ struct TTestEnv
     }
 };
 
-TTestEnv CreateTestEnv(IBlockStorePtr service)
+TTestEnv CreateTestEnv(
+    IBlockStorePtr service,
+    bool connectionMonitoringEnabled = true)
 {
     auto server = std::make_shared<TTestServer>();
 
     NProto::TRdmaTarget rdmaTargetProto;
+    rdmaTargetProto.SetConnectionMonitoringEnabled(connectionMonitoringEnabled);
+
     auto config =
         std::make_shared<TBlockstoreServerRdmaTargetConfig>(rdmaTargetProto);
 
@@ -181,22 +185,25 @@ TTestEnv CreateTestEnv(IBlockStorePtr service)
         std::move(target)};
 }
 
-NMonitoring::TIndexMonPage* FindRootPage(const IMonitoringServicePtr& monitoring)
+NMonitoring::IMonPage* FindRdmaTargetPage(
+    const IMonitoringServicePtr& monitoring)
 {
     auto rootPage = monitoring->GetMonPage("blockstore");
-    UNIT_ASSERT(rootPage);
+    if (!rootPage) {
+        return nullptr;
+    }
 
     auto* indexPage =
         dynamic_cast<NMonitoring::TIndexMonPage*>(rootPage.Get());
     UNIT_ASSERT(indexPage);
 
-    return indexPage;
+    return indexPage->FindPage("RdmaTarget");
 }
 
 TString RenderMonPage(const IMonitoringServicePtr& monitoring)
 {
     auto* page = dynamic_cast<NMonitoring::THtmlMonPage*>(
-        FindRootPage(monitoring)->FindPage("RdmaTarget"));
+        FindRdmaTargetPage(monitoring));
     UNIT_ASSERT(page);
 
     TStringStream out;
@@ -506,7 +513,23 @@ Y_UNIT_TEST_SUITE(TRequestHandlerTest)
         auto service = std::make_shared<TTestService>();
         auto env = CreateTestEnv(service);
 
-        UNIT_ASSERT(FindRootPage(env.Monitoring)->FindPage("RdmaTarget"));
+        UNIT_ASSERT(FindRdmaTargetPage(env.Monitoring));
+
+        env.Target->Stop();
+    }
+
+    Y_UNIT_TEST(ShouldNotTrackConnectionsWhenMonitoringIsDisabled)
+    {
+        auto service = std::make_shared<TTestService>();
+        auto env = CreateTestEnv(service, false);
+        auto handler = env.GetHandler();
+
+        UNIT_ASSERT(!FindRdmaTargetPage(env.Monitoring));
+
+        // the handler still has to survive the connection events
+        TTestSession session(4242);
+        handler->OnSessionCreated(session);
+        handler->OnSessionClosed(session.GetId());
 
         env.Target->Stop();
     }