Remove PDiskLocationMap from BSC

6 files changed, 40 insertions, 80 deletions

diff --git a/ydb/core/mind/bscontroller/bsc.cpp b/ydb/core/mind/bscontroller/bsc.cpp
index 93f58ab9ca4..c44f3cc71f0 100644
--- a/ydb/core/mind/bscontroller/bsc.cpp
+++ b/ydb/core/mind/bscontroller/bsc.cpp
@@ -379,11 +379,6 @@ void Out<NKikimr::NBsController::TPDiskId>(IOutputStream &str, const NKikimr::NB
 }
 
 template<>
-void Out<NKikimr::NBsController::TPDiskLocation>(IOutputStream &str, const NKikimr::NBsController::TPDiskLocation &value) {
-    str << value.NodeId << ":" << value.Path.Quote();
-}
-
-template<>
 void Out<NKikimr::NBsController::TVSlotId>(IOutputStream &str, const NKikimr::NBsController::TVSlotId &value) {
     str << value.ToString();
 }
diff --git a/ydb/core/mind/bscontroller/cmds_drive_status.cpp b/ydb/core/mind/bscontroller/cmds_drive_status.cpp
index 55ca69fb814..c91295fb2c2 100644
--- a/ydb/core/mind/bscontroller/cmds_drive_status.cpp
+++ b/ydb/core/mind/bscontroller/cmds_drive_status.cpp
@@ -15,9 +15,9 @@ namespace NKikimr::NBsController {
                 throw TExPDiskNotFound(host, cmd.GetPDiskId(), TString());
             }
         } else {
-            const auto it = PDiskLocationMap.find(TPDiskLocation(host.GetNodeId(), cmd.GetPath()));
-            if (it != PDiskLocationMap.end() && !PDisksToRemove.count(it->second)) {
-                pdiskId = it->second;
+            const std::optional<TPDiskId> found = FindPDiskByLocation(host.GetNodeId(), cmd.GetPath());
+            if (found && !PDisksToRemove.count(*found)) {
+                pdiskId = *found;
             } else {
                 throw TExPDiskNotFound(host, 0, cmd.GetPath());
             }
diff --git a/ydb/core/mind/bscontroller/config.cpp b/ydb/core/mind/bscontroller/config.cpp
index a2b5869e9ba..638a9ffbfbd 100644
--- a/ydb/core/mind/bscontroller/config.cpp
+++ b/ydb/core/mind/bscontroller/config.cpp
@@ -67,7 +67,6 @@ namespace NKikimr::NBsController {
             }
 
             void ApplyPDiskCreated(const TPDiskId &pdiskId, const TPDiskInfo &pdiskInfo) {
-                const TPDiskLocation location(pdiskId.NodeId, pdiskInfo.Path);
                 if (!State.StaticPDisks.count(pdiskId)) {
                     // don't create static PDisks as they are already created
                     NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk *pdisk = CreatePDiskEntry(pdiskId, pdiskInfo);
@@ -77,8 +76,6 @@ namespace NKikimr::NBsController {
 
             void ApplyPDiskDeleted(const TPDiskId &pdiskId, const TPDiskInfo &pdiskInfo) {
                 DeletedPDiskIds.insert(pdiskId);
-                const TNodeId nodeId = pdiskId.NodeId;
-                const TPDiskLocation location(nodeId, pdiskInfo.Path);
                 if (!State.StaticPDisks.count(pdiskId)) {
                     NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk *pdisk = CreatePDiskEntry(pdiskId, pdiskInfo);
                     pdisk->SetEntityStatus(NKikimrBlobStorage::DESTROY);
diff --git a/ydb/core/mind/bscontroller/config.h b/ydb/core/mind/bscontroller/config.h
index 513714a7958..1d419da20ce 100644
--- a/ydb/core/mind/bscontroller/config.h
+++ b/ydb/core/mind/bscontroller/config.h
@@ -63,10 +63,6 @@ namespace NKikimr {
             TCowHolder<Schema::State::NextStoragePoolId::Type> NextStoragePoolId;
 
             // helper classes
-            using TLocationMap = THashMap<TPDiskLocation, TPDiskId>;
-            TLocationMap PDiskLocationMap;
-            TLocationMap StaticPDiskLocationMap;
-
             THostRecordMap HostRecords;
 
             ui64 UniqueId = RandomNumber<ui64>();
@@ -132,7 +128,6 @@ namespace NKikimr {
                 , StoragePoolStat(*controller.StoragePoolStat)
             {
                 Y_VERIFY(HostRecords);
-                Init();
             }
 
             void Commit() {
@@ -204,17 +199,27 @@ namespace NKikimr {
 
             void ApplyConfigUpdates();
 
-        private:
-            void Init() {
-                PDisks.ForEach([this](const TPDiskId& pdiskId, const TPDiskInfo& pdiskInfo) {
-                    const TNodeId &nodeId = pdiskId.NodeId;
-                    TPDiskLocation location{nodeId, pdiskInfo.PathOrSerial()};
-                    PDiskLocationMap.emplace(location, pdiskId);
-                });
-                for (const auto& [pdiskId, pdisk] : StaticPDisks) {
-                    TPDiskLocation location{pdiskId.NodeId, pdisk.Path};
-                    StaticPDiskLocationMap.emplace(location, pdiskId);
+            std::optional<TPDiskId> FindStaticPDiskByLocation(ui32 nodeId, const TString& path) const {
+                for (auto it = StaticPDisks.lower_bound(TPDiskId::MinForNode(nodeId)); it != StaticPDisks.end() &&
+                        it->first.NodeId == nodeId; ++it) {
+                    if (it->second.Path == path) {
+                        return it->first;
+                    }
                 }
+                return std::nullopt;
+            }
+
+            std::optional<TPDiskId> FindPDiskByLocation(ui32 nodeId, const TString& path) const {
+                std::optional<TPDiskId> res;
+                auto callback = [&](const TPDiskId& id, const TPDiskInfo& info) {
+                    if (info.Path == path) {
+                        res = id;
+                        return false;
+                    }
+                    return true;
+                };
+                PDisks.ForEachInRange(TPDiskId::MinForNode(nodeId), TPDiskId::MaxForNode(nodeId), callback);
+                return res;
             }
 
         private:
diff --git a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
index 565ea0582ce..698745df28a 100644
--- a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
+++ b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
@@ -60,21 +60,20 @@ namespace NKikimr {
             }
             const TPDiskCategory category(type, driveInfo->Kind);
 
-            auto pdiskIt = state.PDiskLocationMap.find(TPDiskLocation{nodeId, fsPath});
-            if (pdiskIt != state.PDiskLocationMap.end()) {
-                throw TExError() << "PDisk found in PDiskLocationMap, fsPath# " << fsPath.Quote()
-                    << " pdiskId# " << pdiskIt->second;
+            if (const auto pdiskId = state.FindPDiskByLocation(nodeId, fsPath)) {
+                throw TExError() << "PDisk found in PDisks by specific path, fsPath# " << fsPath.Quote()
+                    << " pdiskId# " << *pdiskId;
             }
 
             ui32 staticSlotUsage = 0;
-            auto staticPDiskIt = state.StaticPDiskLocationMap.find(TPDiskLocation{nodeId, fsPath});
-            if (staticPDiskIt == state.StaticPDiskLocationMap.end()) {
-                staticPDiskIt = state.StaticPDiskLocationMap.find(TPDiskLocation{nodeId, serial.Serial});
+            auto staticPDiskId = state.FindStaticPDiskByLocation(nodeId, fsPath);
+            if (!staticPDiskId) {
+                staticPDiskId = state.FindStaticPDiskByLocation(nodeId, serial.Serial);
             }
-            if (staticPDiskIt != state.StaticPDiskLocationMap.end()) {
+            if (staticPDiskId) {
                 // PDisk is static one, so take it's pdiskId and guid
                 // and check that parameters match
-                pdiskId = staticPDiskIt->second;
+                pdiskId = *staticPDiskId;
                 driveInfo->Guid = CheckStaticPDisk(state, pdiskId, category, driveInfo->PDiskConfig, &staticSlotUsage);
             }
             // Update FK in DriveSerial table and check for guid
@@ -97,10 +96,7 @@ namespace NKikimr {
                 TInstant::Zero(), NKikimrBlobStorage::EDecommitStatus::DECOMMIT_NONE, serial.Serial,
                 TString(), fsPath, staticSlotUsage);
 
-            const TPDiskLocation location(nodeId, serial.Serial);
-            state.PDiskLocationMap.emplace(location, pdiskId);
-            STLOG(PRI_NOTICE, BS_CONTROLLER, BSCFP01, "Create new pdisk", (PDiskId, pdiskId),
-                    (Location, location));
+            STLOG(PRI_NOTICE, BS_CONTROLLER, BSCFP01, "Create new pdisk", (PDiskId, pdiskId), (Path, fsPath));
         }
 
         void TBlobStorageController::ValidatePDiskWithSerial(TConfigState& state, ui32 nodeId, const TSerial& serial,
@@ -127,10 +123,10 @@ namespace NKikimr {
                     << " guid from PDisks# " << pdiskInfo->Guid;
             }
 
-            const TPDiskLocation location(*driveInfo.NodeId, serial.Serial);
-            if (state.PDiskLocationMap.count(location) + state.StaticPDiskLocationMap.count(location) == 0) {
+            const TString& path = serial.Serial;
+            if (!state.FindStaticPDiskByLocation(*driveInfo.NodeId, path) && !state.FindPDiskByLocation(*driveInfo.NodeId, path)) {
                 throw TExError() << "Drive is in ALLOCATED state and PDisk is created,"
-                    " but is not found neither in PDiskLocationMap, nor in StaticPDiskLocationMap";
+                    " but is not found neither in PDisks, nor in StaticPDisks by specific path";
             }
 
             if (nodeId && nodeId != *driveInfo.NodeId) {
@@ -192,15 +188,13 @@ namespace NKikimr {
                     }
 
                     for (const auto& [drive, driveInfo] : hostConfig.Drives) {
-                        const TPDiskLocation location(*nodeId, drive.Path);
                         TPDiskId pdiskId;
                         const TPDiskCategory category(PDiskTypeToPDiskType(driveInfo.Type), driveInfo.Kind);
 
                         // check if we already have spawned some PDisk at this location
-                        auto pdiskIt = state.PDiskLocationMap.find(location);
-                        if (pdiskIt != state.PDiskLocationMap.end()) {
+                        if (const auto found = state.FindPDiskByLocation(*nodeId, drive.Path)) {
                             // yes, we do; find it by id and update some characteristics (that we can update)
-                            pdiskId = pdiskIt->second;
+                            pdiskId = *found;
                             const TPDiskInfo *pdisk = state.PDisks.Find(pdiskId);
                             Y_VERIFY(pdisk);
                             // update PDisk configuration if needed
@@ -220,9 +214,9 @@ namespace NKikimr {
 
                             // no, this disk is not in map yet; see if it is mentioned in static configuration
                             ui32 staticSlotUsage = 0;
-                            if (auto pdiskIt = state.StaticPDiskLocationMap.find(location); pdiskIt != state.StaticPDiskLocationMap.end()) {
+                            if (const auto found = state.FindStaticPDiskByLocation(*nodeId, drive.Path)) {
                                 // yes, take some data from static configuration
-                                pdiskId = pdiskIt->second;
+                                pdiskId = *found;
                                 guid = CheckStaticPDisk(state, pdiskId, category, driveInfo.PDiskConfig, &staticSlotUsage);
                             } else {
                                 pdiskId = FindFirstEmptyPDiskId(state.PDisks, *nodeId);
@@ -249,9 +243,8 @@ namespace NKikimr {
                                 currentSerial, currentSerial, TString(), staticSlotUsage);
 
                             // insert PDisk into location map
-                            state.PDiskLocationMap.emplace(location, pdiskId);
                             STLOG(PRI_NOTICE, BS_CONTROLLER, BSCFP02, "Create new pdisk", (PDiskId, pdiskId),
-                                    (Location, location));
+                                (Path, path));
                         }
 
                         state.PDisksToRemove.erase(pdiskId);
diff --git a/ydb/core/mind/bscontroller/types.h b/ydb/core/mind/bscontroller/types.h
index 9fe11a75b80..31a6ac15a5e 100644
--- a/ydb/core/mind/bscontroller/types.h
+++ b/ydb/core/mind/bscontroller/types.h
@@ -8,7 +8,6 @@
 namespace NKikimr::NBsController {
     struct TPDiskId;
     struct TVSlotId;
-    struct TPDiskLocation;
 }
 
 template<>
@@ -21,11 +20,6 @@ struct THash<NKikimr::NBsController::TVSlotId> {
     size_t operator ()(NKikimr::NBsController::TVSlotId) const;
 };
 
-template<>
-struct THash<NKikimr::NBsController::TPDiskLocation> {
-    size_t operator ()(const NKikimr::NBsController::TPDiskLocation&) const;
-};
-
 namespace NKikimr {
     namespace NBsController {
 
@@ -413,24 +407,6 @@ namespace NKikimr {
             }
         };
 
-        struct TPDiskLocation {
-            TNodeId NodeId;
-            TString Path;
-
-            TPDiskLocation() = default;
-            TPDiskLocation(const TPDiskLocation&) = default;
-            TPDiskLocation(TPDiskLocation&&) = default;
-
-            TPDiskLocation(TNodeId nodeId, TString path)
-                : NodeId(nodeId)
-                , Path(std::move(path))
-            {}
-
-            friend bool operator ==(const TPDiskLocation& x, const TPDiskLocation& y) {
-                return x.NodeId == y.NodeId && x.Path == y.Path;
-            }
-        };
-
     } // NBsController
 } // NKikimr
 
@@ -446,12 +422,6 @@ inline size_t THash<NKikimr::NBsController::TVSlotId>::operator ()(NKikimr::NBsC
     return THash<T>()(key);
 }
 
-inline size_t THash<NKikimr::NBsController::TPDiskLocation>::operator ()(const NKikimr::NBsController::TPDiskLocation& x) const {
-    auto value = std::tie(x.NodeId, x.Path);
-    using T = decltype(value);
-    return THash<T>()(value);
-}
-
 template<>
 inline NKikimr::NBsController::TPDiskId Min<NKikimr::NBsController::TPDiskId>() noexcept {
     using T = NKikimr::NBsController::Schema::PDisk;