Revert "KIKIMR-11137 PDisk restart button"

This reverts commit 9d82932fee76342f47bd05ea78395d59781c2b40, reversing
changes made to b6df980b3aef9c49fc9868d17eb224b2fcc75a09.

.mapping.json

@@ -3466,11 +3466,6 @@
   "ydb/core/blobstorage/ut_blobstorage/ut_replication/CMakeLists.linux-x86_64.txt":"",
   "ydb/core/blobstorage/ut_blobstorage/ut_replication/CMakeLists.txt":"",
   "ydb/core/blobstorage/ut_blobstorage/ut_replication/CMakeLists.windows-x86_64.txt":"",
-  "ydb/core/blobstorage/ut_blobstorage/ut_restart_pdisk/CMakeLists.darwin-x86_64.txt":"",
-  "ydb/core/blobstorage/ut_blobstorage/ut_restart_pdisk/CMakeLists.linux-aarch64.txt":"",
-  "ydb/core/blobstorage/ut_blobstorage/ut_restart_pdisk/CMakeLists.linux-x86_64.txt":"",
-  "ydb/core/blobstorage/ut_blobstorage/ut_restart_pdisk/CMakeLists.txt":"",
-  "ydb/core/blobstorage/ut_blobstorage/ut_restart_pdisk/CMakeLists.windows-x86_64.txt":"",
   "ydb/core/blobstorage/ut_blobstorage/ut_scrub/CMakeLists.darwin-x86_64.txt":"",
   "ydb/core/blobstorage/ut_blobstorage/ut_scrub/CMakeLists.linux-aarch64.txt":"",
   "ydb/core/blobstorage/ut_blobstorage/ut_scrub/CMakeLists.linux-x86_64.txt":"",

ydb/core/base/blobstorage.h

@@ -787,7 +787,7 @@ struct TEvBlobStorage {
         // EvControllerReadSchemeString = EvPut + 11 * 512,
         // EvControllerReadDataString,
         EvControllerRegisterNode = EvPut + 11 * 512 + 2,
-        EvControllerCreatePDisk, // Not used.
+        EvControllerCreatePDisk,
         EvControllerCreateVDiskSlots,
         EvControllerCreateGroup,
         EvControllerSelectGroups,
@@ -821,7 +821,7 @@ struct TEvBlobStorage {
         // EvControllerReadSchemeStringResult = EvPut + 12 * 512,
         // EvControllerReadDataStringResult,
         EvControllerNodeServiceSetUpdate = EvPut + 12 * 512 + 2,
-        EvControllerCreatePDiskResult, // Not used.
+        EvControllerCreatePDiskResult,
         EvControllerCreateVDiskSlotsResult,
         EvControllerCreateGroupResult,
         EvControllerSelectGroupsResult,
@@ -851,9 +851,9 @@ struct TEvBlobStorage {
 
         // node controller internal messages
         EvRegisterNodeRetry = EvPut + 14 * 512,
-        EvAskWardenRestartPDisk,
+        EvAskRestartPDisk,
         EvRestartPDisk,
-        EvNotifyWardenPDiskRestarted,
+        EvRestartPDiskResult,
         EvNodeWardenQueryGroupInfo,
         EvNodeWardenGroupInfo,
         EvNodeConfigPush,
@@ -2355,10 +2355,10 @@ struct TEvBlobStorage {
     struct TEvDropDonor;
     struct TEvBunchOfEvents;
 
+    struct TEvAskRestartPDisk;
     struct TEvAskRestartVDisk;
-    struct TEvAskWardenRestartPDisk;
-    struct TEvAskWardenRestartPDiskResult;
-    struct TEvNotifyWardenPDiskRestarted;
+    struct TEvRestartPDisk;
+    struct TEvRestartPDiskResult;
 };
 
 // EPutHandleClass defines BlobStorage queue to a request to

ydb/core/blobstorage/base/blobstorage_events.h

@@ -85,6 +85,7 @@ namespace NKikimr {
         }
     };
 
+
     struct TEvBlobStorage::TEvControllerNodeServiceSetUpdate : public TEventPB<
         TEvBlobStorage::TEvControllerNodeServiceSetUpdate,
         NKikimrBlobStorage::TEvControllerNodeServiceSetUpdate,
@@ -422,10 +423,10 @@ namespace NKikimr {
         }
     };
 
-    struct TEvBlobStorage::TEvAskWardenRestartPDisk : TEventLocal<TEvAskWardenRestartPDisk, EvAskWardenRestartPDisk> {
+    struct TEvBlobStorage::TEvAskRestartPDisk : TEventLocal<TEvAskRestartPDisk, EvAskRestartPDisk> {
         const ui32 PDiskId;
 
-        TEvAskWardenRestartPDisk(const ui32& pdiskId)
+        TEvAskRestartPDisk(const ui32& pdiskId)
             : PDiskId(pdiskId)
         {}
     };
@@ -443,28 +444,23 @@ namespace NKikimr {
         {}
     };
 
-    struct TEvBlobStorage::TEvAskWardenRestartPDiskResult : TEventLocal<TEvAskWardenRestartPDiskResult, EvRestartPDisk> {
+    struct TEvBlobStorage::TEvRestartPDisk : TEventLocal<TEvRestartPDisk, EvRestartPDisk> {
         const ui32 PDiskId;
         const NPDisk::TMainKey MainKey;
-        const bool RestartAllowed;
         TIntrusivePtr<TPDiskConfig> Config;
-        TString Details;
 
-        TEvAskWardenRestartPDiskResult(const ui32 pdiskId, const NPDisk::TMainKey& mainKey, const bool restartAllowed, const TIntrusivePtr<TPDiskConfig>& config, 
-            TString details = "")
+        TEvRestartPDisk(const ui32& pdiskId, const NPDisk::TMainKey& mainKey, const TIntrusivePtr<TPDiskConfig>& config)
             : PDiskId(pdiskId)
             , MainKey(mainKey)
-            , RestartAllowed(restartAllowed)
             , Config(config)
-            , Details(details)
         {}
     };
 
-    struct TEvBlobStorage::TEvNotifyWardenPDiskRestarted : TEventLocal<TEvNotifyWardenPDiskRestarted, EvNotifyWardenPDiskRestarted> {
+    struct TEvBlobStorage::TEvRestartPDiskResult : TEventLocal<TEvRestartPDiskResult, EvRestartPDiskResult> {
         const ui32 PDiskId;
         NKikimrProto::EReplyStatus Status;
 
-        TEvNotifyWardenPDiskRestarted(const ui32 pdiskId, NKikimrProto::EReplyStatus status = NKikimrProto::EReplyStatus::OK)
+        TEvRestartPDiskResult(const ui32& pdiskId, NKikimrProto::EReplyStatus status = NKikimrProto::EReplyStatus::OK)
             : PDiskId(pdiskId)
             , Status(status)
         {}

ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp

@@ -822,49 +822,6 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
         TestHttpMonForPath("");
         TestHttpMonForPath("/json/groups");
     }
-
-    Y_UNIT_TEST(TestReceivedPDiskRestartNotAllowed) {
-        TTestActorSystem runtime(1);
-        runtime.Start();
-
-        ui32 nodeId = 1;
-        ui32 pdiskId = 1337;
-        ui64 cookie = 555;
-
-        auto *appData = runtime.GetAppData();
-        appData->DomainsInfo->AddDomain(TDomainsInfo::TDomain::ConstructEmptyDomain("dom", 1).Release());
-
-        TIntrusivePtr<TNodeWardenConfig> nodeWardenConfig(new TNodeWardenConfig(static_cast<IPDiskServiceFactory*>(new TRealPDiskServiceFactory())));
-
-        IActor* ac = CreateBSNodeWarden(nodeWardenConfig.Release());
-
-        TActorId nodeWarden = runtime.Register(ac, nodeId);
-
-        auto fakeBSC = runtime.AllocateEdgeActor(nodeId);
-
-        TActorId pdiskActorId = runtime.AllocateEdgeActor(nodeId);
-        TActorId pdiskServiceId = MakeBlobStoragePDiskID(nodeId, pdiskId);
-
-        runtime.RegisterService(pdiskServiceId, pdiskActorId);
-
-        runtime.Send(new IEventHandle(nodeWarden, pdiskActorId, new TEvBlobStorage::TEvAskWardenRestartPDisk(pdiskId), 0, cookie), nodeId);
-
-        auto responseEvent = new TEvBlobStorage::TEvControllerConfigResponse();
-
-        auto res = responseEvent->Record.MutableResponse();
-        res->SetSuccess(false);
-        res->SetErrorDescription("Fake error");
-
-        runtime.Send(new IEventHandle(nodeWarden, fakeBSC, responseEvent, 0, cookie), nodeId);
-
-        auto evPtr = runtime.WaitForEdgeActorEvent<TEvBlobStorage::TEvAskWardenRestartPDiskResult>(pdiskActorId);
-        auto restartPDiskEv = evPtr->Get();
-
-        UNIT_ASSERT(!restartPDiskEv->RestartAllowed);
-        UNIT_ASSERT_STRINGS_EQUAL("Fake error", restartPDiskEv->Details);
-
-        UNIT_ASSERT_EQUAL(pdiskId, restartPDiskEv->PDiskId);
-    }
 }
 
 } // namespace NBlobStorageNodeWardenTest

ydb/core/blobstorage/nodewarden/node_warden_impl.cpp

@@ -399,43 +399,15 @@ void TNodeWarden::SendVDiskReport(TVSlotId vslotId, const TVDiskID &vDiskId, NKi
     SendToController(std::move(report));
 }
 
-void TNodeWarden::Handle(TEvBlobStorage::TEvAskWardenRestartPDisk::TPtr ev) {
-    auto pdiskId = ev->Get()->PDiskId;
-    auto requestCookie = ev->Cookie;
-
-    for (auto it = PDiskRestartRequests.begin(); it != PDiskRestartRequests.end(); it++) {
-        if (it->second == pdiskId) {
-            const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
-
-            Cfg->PDiskKey.Initialize();
-            Send(actorId, new TEvBlobStorage::TEvAskWardenRestartPDiskResult(pdiskId, Cfg->PDiskKey, false, nullptr, "Restart already requested"));
-
-            return;
-        }
+void TNodeWarden::Handle(TEvBlobStorage::TEvAskRestartPDisk::TPtr ev) {
+    const auto id = ev->Get()->PDiskId;
+    if (auto it = LocalPDisks.find(TPDiskKey{LocalNodeId, id}); it != LocalPDisks.end()) {
+        RestartLocalPDiskStart(id, CreatePDiskConfig(it->second.Record));
     }
-    
-    PDiskRestartRequests[requestCookie] = pdiskId;
-
-    AskBSCToRestartPDisk(pdiskId, requestCookie);
 }
 
-void TNodeWarden::Handle(TEvBlobStorage::TEvNotifyWardenPDiskRestarted::TPtr ev) {
-    OnPDiskRestartFinished(ev->Get()->PDiskId, ev->Get()->Status);
-}
-
-void TNodeWarden::Handle(TEvBlobStorage::TEvControllerConfigResponse::TPtr ev) {
-    // Can be a response to RestartPDisk or DropDonorDisk. We are only interested in RestartPDisk.
-    auto it = PDiskRestartRequests.find(ev->Cookie);
-    // If cookie is in PDiskRestartRequests, then it's a RestartPDisk.
-    if (it != PDiskRestartRequests.end()) {
-        auto res = ev->Get()->Record.GetResponse();
-        ui32 pdiskId = it->second;
-        PDiskRestartRequests.erase(it);
-        
-        if (!res.GetSuccess()) {
-            OnUnableToRestartPDisk(pdiskId, res.GetErrorDescription());
-        }
-    }
+void TNodeWarden::Handle(TEvBlobStorage::TEvRestartPDiskResult::TPtr ev) {
+    RestartLocalPDiskFinish(ev->Get()->PDiskId, ev->Get()->Status);
 }
 
 void TNodeWarden::Handle(TEvBlobStorage::TEvControllerUpdateDiskStatus::TPtr ev) {
@@ -516,6 +488,7 @@ void TNodeWarden::Handle(TEvPrivate::TEvUpdateNodeDrives::TPtr&) {
     Schedule(TDuration::Seconds(10), new TEvPrivate::TEvUpdateNodeDrives());
 }
 
+
 void TNodeWarden::SendDiskMetrics(bool reportMetrics) {
     STLOG(PRI_TRACE, BS_NODE, NW45, "SendDiskMetrics", (ReportMetrics, reportMetrics));
 

ydb/core/blobstorage/nodewarden/node_warden_impl.h

@@ -90,7 +90,7 @@ namespace NKikimr::NStorage {
 
         std::map<TPDiskKey, TPDiskRecord> LocalPDisks;
         TIntrusiveList<TPDiskRecord, TUnreportedMetricTag> PDisksWithUnreportedMetrics;
-        std::map<ui64, ui32> PDiskRestartRequests;
+        std::set<TPDiskKey> InFlightRestartedPDisks; // for sanity checks only
 
         ui64 LastScrubCookie = RandomNumber<ui64>();
 
@@ -152,12 +152,10 @@ namespace NKikimr::NStorage {
 
         TIntrusivePtr<TPDiskConfig> CreatePDiskConfig(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk);
         void StartLocalPDisk(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk);
-        void AskBSCToRestartPDisk(ui32 pdiskId, ui64 requestCookie);
-        void OnPDiskRestartFinished(ui32 pdiskId, NKikimrProto::EReplyStatus status);
+        void RestartLocalPDiskStart(ui32 pdiskId, TIntrusivePtr<TPDiskConfig> pdiskConfig);
+        void RestartLocalPDiskFinish(ui32 pdiskId, NKikimrProto::EReplyStatus status);
         void DestroyLocalPDisk(ui32 pdiskId);
 
-        void DoRestartLocalPDisk(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk);
-        void OnUnableToRestartPDisk(ui32 pdiskId, TString error);
         void ApplyServiceSetPDisks(const NKikimrBlobStorage::TNodeWardenServiceSet& serviceSet);
 
         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -451,8 +449,6 @@ namespace NKikimr::NStorage {
         void SendVDiskReport(TVSlotId vslotId, const TVDiskID& vdiskId,
             NKikimrBlobStorage::TEvControllerNodeReport::EVDiskPhase phase);
 
-        void SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase);
-
         void Handle(TEvBlobStorage::TEvControllerUpdateDiskStatus::TPtr ev);
         void Handle(TEvBlobStorage::TEvControllerGroupMetricsExchange::TPtr ev);
         void Handle(TEvPrivate::TEvSendDiskMetrics::TPtr&);
@@ -467,10 +463,9 @@ namespace NKikimr::NStorage {
         void Handle(TEvStatusUpdate::TPtr ev);
 
         void Handle(TEvBlobStorage::TEvDropDonor::TPtr ev);
+        void Handle(TEvBlobStorage::TEvAskRestartPDisk::TPtr ev);
         void Handle(TEvBlobStorage::TEvAskRestartVDisk::TPtr ev);
-        void Handle(TEvBlobStorage::TEvAskWardenRestartPDisk::TPtr ev);
-        void Handle(TEvBlobStorage::TEvNotifyWardenPDiskRestarted::TPtr ev);
-        void Handle(TEvBlobStorage::TEvControllerConfigResponse::TPtr ev);
+        void Handle(TEvBlobStorage::TEvRestartPDiskResult::TPtr ev);
 
         void FillInVDiskStatus(google::protobuf::RepeatedPtrField<NKikimrBlobStorage::TVDiskStatus> *pb, bool initial);
 
@@ -540,9 +535,9 @@ namespace NKikimr::NStorage {
 
                 hFunc(TEvStatusUpdate, Handle);
                 hFunc(TEvBlobStorage::TEvDropDonor, Handle);
+                hFunc(TEvBlobStorage::TEvAskRestartPDisk, Handle);
                 hFunc(TEvBlobStorage::TEvAskRestartVDisk, Handle);
-                hFunc(TEvBlobStorage::TEvAskWardenRestartPDisk, Handle);
-                hFunc(TEvBlobStorage::TEvNotifyWardenPDiskRestarted, Handle);
+                hFunc(TEvBlobStorage::TEvRestartPDiskResult, Handle);
 
                 hFunc(TEvGroupStatReport, Handle);
 
@@ -569,7 +564,8 @@ namespace NKikimr::NStorage {
                 // proxy requests for the NodeWhiteboard to prevent races
                 hFunc(NNodeWhiteboard::TEvWhiteboard::TEvBSGroupStateUpdate, Handle);
 
-                hFunc(TEvBlobStorage::TEvControllerConfigResponse, Handle);
+                // ignore as it is used only in response to DropDonorDisk cmd
+                IgnoreFunc(TEvBlobStorage::TEvControllerConfigResponse);
 
                 cFunc(TEvPrivate::EvReadCache, HandleReadCache);
                 fFunc(TEvPrivate::EvGetGroup, HandleGetGroup);

ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp

@@ -192,32 +192,33 @@ namespace NKikimr::NStorage {
         }
     }
 
-    void TNodeWarden::SendPDiskReport(ui32 pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::EPDiskPhase phase) {
-        STLOG(PRI_DEBUG, BS_NODE, NW41, "SendPDiskReport", (PDiskId, pdiskId), (Phase, phase));
-
-        auto report = std::make_unique<TEvBlobStorage::TEvControllerNodeReport>(LocalNodeId);
-        auto *pReport = report->Record.AddPDiskReports();
-        pReport->SetPDiskId(pdiskId);
-        pReport->SetPhase(phase);
-        
-        SendToController(std::move(report));
-    }
-
-    void TNodeWarden::AskBSCToRestartPDisk(ui32 pdiskId, ui64 requestCookie) {
-        auto ev = std::make_unique<TEvBlobStorage::TEvControllerConfigRequest>();
+    void TNodeWarden::RestartLocalPDiskStart(ui32 pdiskId, TIntrusivePtr<TPDiskConfig> pdiskConfig) {
+        auto it = LocalPDisks.find(TPDiskKey(LocalNodeId, pdiskId));
+        if (it == LocalPDisks.end()) {
+            STLOG(PRI_WARN, BS_NODE, NW66, "Cannot restart local pdisk since there is no such pdisk",
+                    (NodeId, LocalNodeId), (PDiskId, pdiskId));
+            return;
+        }
 
-        NKikimrBlobStorage::TRestartPDisk* cmd = ev->Record.MutableRequest()->AddCommand()->MutableRestartPDisk();
-        
-        auto targetPDiskId = cmd->MutableTargetPDiskId();
-        targetPDiskId->SetNodeId(LocalNodeId);
-        targetPDiskId->SetPDiskId(pdiskId);
+        bool inserted = InFlightRestartedPDisks.emplace(LocalNodeId, pdiskId).second;
+        if (!inserted) {
+            STLOG(PRI_WARN, BS_NODE, NW67, "Cannot restart local pdisk since it already in the process of restart",
+                    (NodeId, LocalNodeId), (PDiskId, pdiskId));
+            return;
+        }
 
-        SendToController(std::move(ev), requestCookie);
+        const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
+        Cfg->PDiskKey.Initialize();
+        Send(actorId, new TEvBlobStorage::TEvRestartPDisk(pdiskId, Cfg->PDiskKey, pdiskConfig));
+        STLOG(PRI_NOTICE, BS_NODE, NW69, "RestartLocalPDisk is started", (PDiskId, pdiskId));
     }
 
-    void TNodeWarden::OnPDiskRestartFinished(ui32 pdiskId, NKikimrProto::EReplyStatus status) {
+    void TNodeWarden::RestartLocalPDiskFinish(ui32 pdiskId, NKikimrProto::EReplyStatus status) {
         const TPDiskKey pdiskKey(LocalNodeId, pdiskId);
 
+        size_t erasedCount = InFlightRestartedPDisks.erase(pdiskKey);
+        Y_VERIFY_S(erasedCount == 1, "PDiskId# " << pdiskId << " restarted, but wasn't in the process of removal");
+
         const TVSlotId from(pdiskKey.NodeId, pdiskKey.PDiskId, 0);
         const TVSlotId to(pdiskKey.NodeId, pdiskKey.PDiskId, Max<ui32>());
 
@@ -252,35 +253,6 @@ namespace NKikimr::NStorage {
                 }
             }
         }
-        
-        SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_RESTARTED);
-    }
-
-    void TNodeWarden::DoRestartLocalPDisk(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk) {
-        ui32 pdiskId = pdisk.GetPDiskID();
-
-        const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
-
-        auto it = LocalPDisks.find(TPDiskKey(LocalNodeId, pdiskId));
-        if (it == LocalPDisks.end()) {
-            // This can happen if warden didn't handle pdisk's restart before node's restart.
-            // In this case, PDisk has EntityStatus::RESTART instead of EntityStatus::INITIAL.
-            StartLocalPDisk(pdisk);
-            SendPDiskReport(pdiskId, NKikimrBlobStorage::TEvControllerNodeReport::PD_RESTARTED);
-            return;
-        }
-
-        TIntrusivePtr<TPDiskConfig> pdiskConfig = CreatePDiskConfig(it->second.Record);
-
-        Cfg->PDiskKey.Initialize();
-        Send(actorId, new TEvBlobStorage::TEvAskWardenRestartPDiskResult(pdiskId, Cfg->PDiskKey, true, pdiskConfig));
-    }
-
-    void TNodeWarden::OnUnableToRestartPDisk(ui32 pdiskId, TString error) {
-        const TActorId actorId = MakeBlobStoragePDiskID(LocalNodeId, pdiskId);
-
-        Cfg->PDiskKey.Initialize();
-        Send(actorId, new TEvBlobStorage::TEvAskWardenRestartPDiskResult(pdiskId, Cfg->PDiskKey, false, nullptr, error));
     }
 
     void TNodeWarden::ApplyServiceSetPDisks(const NKikimrBlobStorage::TNodeWardenServiceSet& serviceSet) {
@@ -305,7 +277,10 @@ namespace NKikimr::NStorage {
                     break;
 
                 case NKikimrBlobStorage::RESTART:
-                    DoRestartLocalPDisk(pdisk);
+                    if (auto it = LocalPDisks.find({pdisk.GetNodeID(), pdisk.GetPDiskID()}); it != LocalPDisks.end()) {
+                        it->second.Record = pdisk;
+                    }
+                    RestartLocalPDiskStart(pdisk.GetPDiskID(), CreatePDiskConfig(pdisk));
                     break;
             }
         }

ydb/core/blobstorage/nodewarden/node_warden_pipe.cpp

@@ -55,7 +55,6 @@ void TNodeWarden::OnPipeError() {
             VDisksWithUnreportedMetrics.PushBack(&vdisk);
         }
     }
-    PDiskRestartRequests.clear();
     EstablishPipe();
 }
 

ydb/core/blobstorage/nodewarden/node_warden_vdisk.cpp

@@ -57,14 +57,16 @@ namespace NKikimr::NStorage {
     void TNodeWarden::StartLocalVDiskActor(TVDiskRecord& vdisk, TDuration yardInitDelay) {
         const TVSlotId vslotId = vdisk.GetVSlotId();
         const ui64 pdiskGuid = vdisk.Config.GetVDiskLocation().GetPDiskGuid();
+        const bool restartInFlight = InFlightRestartedPDisks.count({vslotId.NodeId, vslotId.PDiskId});
         const bool donorMode = vdisk.Config.HasDonorMode();
         const bool readOnly = vdisk.Config.GetReadOnly();
         Y_VERIFY_S(!donorMode || !readOnly, "Only one of modes should be enabled: donorMode " << donorMode << ", readOnly " << readOnly);
 
-        STLOG(PRI_DEBUG, BS_NODE, NW23, "StartLocalVDiskActor", (SlayInFlight, SlayInFlight.contains(vslotId)),
-            (VDiskId, vdisk.GetVDiskId()), (VSlotId, vslotId), (PDiskGuid, pdiskGuid), (DonorMode, donorMode));
+        STLOG(PRI_DEBUG, BS_NODE, NW23, "StartLocalVDiskActor", (RestartInFlight, restartInFlight),
+            (SlayInFlight, SlayInFlight.contains(vslotId)), (VDiskId, vdisk.GetVDiskId()), (VSlotId, vslotId),
+            (PDiskGuid, pdiskGuid), (DonorMode, donorMode));
 
-        if (SlayInFlight.contains(vslotId)) {
+        if (restartInFlight || SlayInFlight.contains(vslotId)) {
             return;
         }
 

ydb/core/blobstorage/pdisk/blobstorage_pdisk_actor.cpp

@@ -75,13 +75,11 @@ class TPDiskActor : public TActorBootstrapped<TPDiskActor> {
 
     THolder<TThread> FormattingThread;
     bool IsFormattingNow = false;
-    std::function<void(bool, TString&)> PendingRestartResponse;
+    std::function<void()> PendingRestartResponse;
 
     TActorId NodeWhiteboardServiceId;
     TActorId NodeWardenServiceId;
 
-    ui32 NextRestartRequestCookie = 0;
-
     THolder<IEventHandle> ControledStartResult;
 
     class TWhiteboardFlag {
@@ -968,31 +966,31 @@ public:
         InitError("io error");
     }
 
-    void Handle(TEvBlobStorage::TEvAskWardenRestartPDiskResult::TPtr &ev) {
-        bool restartAllowed = ev->Get()->RestartAllowed;
-
-        if (restartAllowed) {    
-            MainKey = ev->Get()->MainKey;
-            SecureWipeBuffer((ui8*)ev->Get()->MainKey.Keys.data(), sizeof(NPDisk::TKey) * ev->Get()->MainKey.Keys.size());
-            LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::BS_PDISK, "PDiskId# " << PDisk->PDiskId
-                    << " Going to restart PDisk since recieved TEvAskWardenRestartPDiskResult");
-
-            PDisk->Stop();
+    void Handle(TEvBlobStorage::TEvRestartPDisk::TPtr &ev) {
+        if (CurrentStateFunc() == &TPDiskActor::StateInit
+              || CurrentStateFunc() == &TPDiskActor::StateOnline && !Cfg->SectorMap) {
+            Send(ev->Sender, new TEvBlobStorage::TEvRestartPDiskResult(PDisk->PDiskId,
+                        NKikimrProto::EReplyStatus::ERROR));
+            return;
+        }
 
-            auto& newCfg = ev->Get()->Config;
-            if (newCfg) {
-                Y_VERIFY_S(Cfg->PDiskId == PDisk->PDiskId,
-                        "New config's PDiskId# " << newCfg->PDiskId << " is not equal to real PDiskId# " << PDisk->PDiskId);
-                Cfg = std::move(newCfg);
-            }
-            
-            StartPDiskThread();
+        MainKey = ev->Get()->MainKey;
+        SecureWipeBuffer((ui8*)ev->Get()->MainKey.Keys.data(), sizeof(NPDisk::TKey) * ev->Get()->MainKey.Keys.size());
+        LOG_NOTICE_S(*TlsActivationContext, NKikimrServices::BS_PDISK, "PDiskId# " << PDisk->PDiskId
+                << " Going to restart PDisk since recieved TEvRestartPDisk");
+        PDisk->Stop();
 
-            Send(ev->Sender, new TEvBlobStorage::TEvNotifyWardenPDiskRestarted(PDisk->PDiskId));
+        auto& newCfg = ev->Get()->Config;
+        if (newCfg) {
+            Y_VERIFY_S(Cfg->PDiskId == PDisk->PDiskId,
+                    "New config's PDiskId# " << newCfg->PDiskId << " is not equal to real PDiskId# " << PDisk->PDiskId);
+            Cfg = std::move(newCfg);
         }
+        StartPDiskThread();
 
+        Send(ev->Sender, new TEvBlobStorage::TEvRestartPDiskResult(PDisk->PDiskId));
         if (PendingRestartResponse) {
-            PendingRestartResponse(restartAllowed, ev->Get()->Details);
+            PendingRestartResponse();
             PendingRestartResponse = {};
         }
     }
@@ -1069,28 +1067,14 @@ public:
             }
         }
         if (cgi.Has("restartPDisk")) {
-            ui32 cookieIdxPart = NextRestartRequestCookie++;
-            ui64 fullCookie = (((ui64) PDisk->PDiskId) << 32) | cookieIdxPart; // This way cookie will be unique no matter the disk.
-
-            Send(NodeWardenServiceId, new TEvBlobStorage::TEvAskWardenRestartPDisk(PDisk->PDiskId), fullCookie);
-            // Send responce later when restart command will be received.
-            PendingRestartResponse = [this, actor = ev->Sender] (bool restartAllowed, TString& details) {
-                TStringStream jsonBuilder;
-                jsonBuilder << NMonitoring::HTTPOKJSON;
-
-                jsonBuilder << "{\"result\":" << (restartAllowed ? "true" : "false");
-
-                if (!restartAllowed) {
-                    jsonBuilder << ", \"error\": \"" << details << "\"";
-                }
-
-                jsonBuilder << "}";
-                
-                auto result = std::make_unique<NMon::TEvHttpInfoRes>(jsonBuilder.Str(), 0, NMon::IEvHttpInfoRes::EContentType::Custom);
-
-                Send(actor, result.release());
-            };
-            return;
+            if (Cfg->SectorMap || CurrentStateFunc() == &TPDiskActor::StateError) {
+                Send(NodeWardenServiceId, new TEvBlobStorage::TEvAskRestartPDisk(PDisk->PDiskId));
+                // Send responce later when restart command will be received
+                PendingRestartResponse = [this, actor = ev->Sender] () {
+                    Send(actor, new NMon::TEvHttpInfoRes(""));
+                };
+                return;
+            }
         } else if (cgi.Has("stopPDisk")) {
             if (Cfg->SectorMap) {
                 *PDisk->Mon.PDiskState = NKikimrBlobStorage::TPDiskState::DeviceIoError;
@@ -1194,7 +1178,7 @@ public:
             hFunc(NMon::TEvHttpInfo, InitHandle);
             cFunc(TEvents::TSystem::Wakeup, HandleWakeup);
             hFunc(NPDisk::TEvDeviceError, Handle);
-            hFunc(TEvBlobStorage::TEvAskWardenRestartPDiskResult, Handle);
+            hFunc(TEvBlobStorage::TEvRestartPDisk, Handle);
             hFunc(NPDisk::TEvFormatReencryptionFinish, InitHandle);
     )
 
@@ -1225,7 +1209,7 @@ public:
             hFunc(NMon::TEvHttpInfo, Handle);
             cFunc(TEvents::TSystem::Wakeup, HandleWakeup);
             hFunc(NPDisk::TEvDeviceError, Handle);
-            hFunc(TEvBlobStorage::TEvAskWardenRestartPDiskResult, Handle);
+            hFunc(TEvBlobStorage::TEvRestartPDisk, Handle);
     )
 
     STRICT_STFUNC(StateError,
@@ -1252,7 +1236,7 @@ public:
             hFunc(NMon::TEvHttpInfo, Handle);
             cFunc(TEvents::TSystem::Wakeup, HandleWakeup);
             hFunc(NPDisk::TEvDeviceError, Handle);
-            hFunc(TEvBlobStorage::TEvAskWardenRestartPDiskResult, Handle);
+            hFunc(TEvBlobStorage::TEvRestartPDisk, Handle);
     )
 };