Tidy up some code in config_fit_pdisks.cpp.

2 files changed, 25 insertions, 23 deletions

diff --git a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
index 8cfae51805a..6cd26c0030d 100644
--- a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
+++ b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
@@ -112,7 +112,7 @@ namespace NKikimr {
         }
 
         // return TString not const TString& to make sure we never use dangling reference
-        TString GetDiskPathFromNode(ui32 nodeId, const TString& serialNumber, const TBlobStorageController::TConfigState& state, bool throwOnError = false) {
+        static TString GetDiskPathFromNode(ui32 nodeId, const TString& serialNumber, const TBlobStorageController::TConfigState& state, bool throwOnError = false) {
             if (auto nodeIt = state.Nodes.Get().find(nodeId); nodeIt != state.Nodes.Get().end()) {
                 for (const auto& [_, driveData] : nodeIt->second.KnownDrives) {
                     if (serialNumber == driveData.SerialNumber) {
@@ -132,7 +132,7 @@ namespace NKikimr {
         }
 
         // return TString not const TString& to make sure we never use dangling reference
-        TString GetDiskSerialNumberFromNode(ui32 nodeId, const TString& path, const TBlobStorageController::TConfigState& state, bool throwOnError = false) {
+        static TString GetDiskSerialNumberFromNode(ui32 nodeId, const TString& path, const TBlobStorageController::TConfigState& state, bool throwOnError = false) {
             if (auto nodeIt = state.Nodes.Get().find(nodeId); nodeIt != state.Nodes.Get().end()) {
                 for (const auto& [_, driveData] : nodeIt->second.KnownDrives) {
                     if (path == driveData.Path) {
@@ -151,7 +151,7 @@ namespace NKikimr {
             return TString();
         }
 
-        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromHostConfig(TBlobStorageController::TConfigState& state, std::set<TBoxId>& relevantBoxes) {
+        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromHostConfig(const TBlobStorageController::TConfigState& state, const std::set<TBoxId>& relevantBoxes) {
             std::unordered_map<TDiskId, TDiskInfo> disks;
 
             const auto& hostConfigs = state.HostConfigs.Get();
@@ -209,10 +209,10 @@ namespace NKikimr {
             return disks;
         }
 
-        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromDrivesSerials(TBlobStorageController::TConfigState& state, std::set<TBoxId>& relevantBoxes) {
+        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromDrivesSerials(const TBlobStorageController::TConfigState& state, const std::set<TBoxId>& relevantBoxes) {
             std::unordered_map<TDiskId, TDiskInfo> disks;
 
-            state.DrivesSerials.ScanRange({}, {}, [&](const auto& serial, const auto& driveInfo, const auto&) {
+            state.DrivesSerials.ForEachInRange({}, {}, [&](const auto& serial, const auto& driveInfo) {
                 if (!relevantBoxes.contains(driveInfo.BoxId)) {
                     return true;
                 }
@@ -264,39 +264,44 @@ namespace NKikimr {
             return disks;
         }
 
-        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromDrivesSerialsAndHostConfig(TBlobStorageController::TConfigState& state, std::set<TBoxId>& relevantBoxes) {
+        static std::unordered_map<TDiskId, TDiskInfo> GetDisksFromDrivesSerialsAndHostConfig(
+            const TBlobStorageController::TConfigState& state, const std::set<TBoxId>& relevantBoxes)
+        {
             auto disksFromDrivesSerials = GetDisksFromDrivesSerials(state, relevantBoxes);
             auto disksFromHostConfig = GetDisksFromHostConfig(state, relevantBoxes);
             disksFromHostConfig.merge(disksFromDrivesSerials);
             return disksFromHostConfig;
         }
 
-        Schema::PDisk::Guid::Type TBlobStorageController::CheckStaticPDisk(TConfigState &state, TPDiskId pdiskId,
-                const TPDiskCategory& category, const TMaybe<Schema::PDisk::PDiskConfig::Type>& pdiskConfig,
-                ui32 *staticSlotUsage) {
-            const TStaticPDiskInfo& info = state.StaticPDisks.at(pdiskId);
+        static Schema::PDisk::Guid::Type GetGuidAndValidateStaticPDisk(
+            const TPDiskId& pdiskId,
+            const TDiskInfo& disk,
+            const TBlobStorageController::TConfigState& state,
+            ui32& staticSlotUsage)
+        {
+            const auto& info = state.StaticPDisks.at(pdiskId);
 
             // create new disk entry; the PDisk with this number MUST NOT exist, otherwise we can
             // have a collision
             if (state.PDisks.Find(pdiskId)) {
                 throw TExError() << "PDisk from static config collides with dynamic one"
-                    << " PDiskId# " << pdiskId;
+                    << TErrorParams::NodeId(pdiskId.NodeId) << TErrorParams::PDiskId(pdiskId.PDiskId);
             }
 
             // validate fields
-            if (pdiskConfig.GetOrElse(TString()) != info.PDiskConfig) {
+            if (disk.PDiskConfig != info.PDiskConfig) {
                 throw TExError() << "PDiskConfig field doesn't match static one"
-                    << " pdiskConfig# " << (pdiskConfig ? FormatPDiskConfig(*pdiskConfig) : "(empty)")
+                    << " pdiskConfig# " << (disk.PDiskConfig ? FormatPDiskConfig(disk.PDiskConfig) : "(empty)")
                     << " info.PDiskConfig# " << FormatPDiskConfig(info.PDiskConfig);
-            } else if (category != info.Category) {
+            } else if (disk.PDiskCategory != info.Category) {
                 throw TExError() << "Type/Kind fields do not match static one";
             }
 
-            *staticSlotUsage = info.StaticSlotUsage;
+            staticSlotUsage = info.StaticSlotUsage;
             return info.Guid;
         }
 
-        void TBlobStorageController::FitPDisksForUserConfig(TConfigState &state) {
+        void TBlobStorageController::FitPDisksForUserConfig(TConfigState& state) {
             auto relevantBoxes = std::exchange(state.Fit.Boxes, {});
             if (relevantBoxes.empty()) {
                 return;
@@ -316,18 +321,17 @@ namespace NKikimr {
                 TPDiskId pdiskId;
                 // check if we already have spawned some PDisk at this location
                 if (auto pdiskIdOptional = NKikimr::NBsController::FindPDisk(disk, state)) {
-                    pdiskId = *pdiskIdOptional;
                     // yes, we have; find it by id and update some characteristics (that we can update)
+                    pdiskId = *pdiskIdOptional;
                     UpdatePDiskIfNeeded(pdiskId, disk, DefaultMaxSlots, state);
                 } else {
-                    // no, this disk is not in map yet; see if it is mentioned in static configuration
-                    Schema::PDisk::Guid::Type guid;
-
+                    // no, we haven't; see if it is mentioned in static configuration
                     ui32 staticSlotUsage = 0;
+                    Schema::PDisk::Guid::Type guid{};
                     if (auto pdiskIdOptional = NKikimr::NBsController::FindStaticPDisk(disk, state)) {
                         // yes, take some data from static configuration
                         pdiskId = *pdiskIdOptional;
-                        guid = CheckStaticPDisk(state, pdiskId, disk.PDiskCategory, disk.PDiskConfig, &staticSlotUsage);
+                        guid = GetGuidAndValidateStaticPDisk(pdiskId, disk, state, staticSlotUsage);
                     } else {
                         pdiskId = FindFirstEmptyPDiskId(state.PDisks, disk.NodeId);
                         guid = RandomNumber<Schema::PDisk::Guid::Type>();
diff --git a/ydb/core/mind/bscontroller/impl.h b/ydb/core/mind/bscontroller/impl.h
index be43cf905e8..17262774630 100644
--- a/ydb/core/mind/bscontroller/impl.h
+++ b/ydb/core/mind/bscontroller/impl.h
@@ -1776,8 +1776,6 @@ private:
 
     void Handle(TEvPrivate::TEvDropDonor::TPtr ev);
 
-    Schema::PDisk::Guid::Type CheckStaticPDisk(TConfigState &state, TPDiskId pdiskId, const TPDiskCategory& category,
-            const TMaybe<Schema::PDisk::PDiskConfig::Type>& pdiskConfig, ui32 *staticSlotUsage);
     void AllocatePDiskWithSerial(TConfigState& state, ui32 nodeId, const TSerial& serial, TDriveSerialInfo *driveInfo);
     void ValidatePDiskWithSerial(TConfigState& state, ui32 nodeId, const TSerial& serial, const TDriveSerialInfo& driveInfo,
             std::function<TDriveSerialInfo*()> getMutableItem);