Merge pull request #14970 from vespa-engine/balder/gc-unused-disk-count-code

GC unused disk dimension.

14 files changed, 78 insertions, 107 deletions

diff --git a/storage/src/tests/bucketdb/bucketmanagertest.cpp b/storage/src/tests/bucketdb/bucketmanagertest.cpp
index 4513d00c903..8a508a2169d 100644
--- a/storage/src/tests/bucketdb/bucketmanagertest.cpp
+++ b/storage/src/tests/bucketdb/bucketmanagertest.cpp
@@ -450,8 +450,8 @@ TEST_F(BucketManagerTest, metrics_generation) {
     _top->doneInit();
     trigger_metric_manager_update();
 
-    ASSERT_EQ(1u, bucket_manager_metrics().disks.size());
-    const DataStoredMetrics& m(*bucket_manager_metrics().disks[0]);
+    ASSERT_TRUE(bucket_manager_metrics().disk);
+    const DataStoredMetrics& m(*bucket_manager_metrics().disk);
     EXPECT_EQ(3, m.buckets.getLast());
     EXPECT_EQ(300, m.docs.getLast());
     EXPECT_EQ(600, m.bytes.getLast());
diff --git a/storage/src/tests/common/metricstest.cpp b/storage/src/tests/common/metricstest.cpp
index c0ccb5bc771..fa46fce5e93 100644
--- a/storage/src/tests/common/metricstest.cpp
+++ b/storage/src/tests/common/metricstest.cpp
@@ -92,15 +92,13 @@ void MetricsTest::SetUp() {
             *_metricManager,
             "status");
 
-    uint16_t diskCount = 1u;
     documentapi::LoadTypeSet::SP loadTypes(_node->getLoadTypes());
 
     _filestorMetrics = std::make_shared<FileStorMetrics>(_node->getLoadTypes()->getMetricLoadTypes());
-    _filestorMetrics->initDiskMetrics(diskCount, loadTypes->getMetricLoadTypes(), 1, 1);
+    _filestorMetrics->initDiskMetrics(loadTypes->getMetricLoadTypes(), 1, 1);
     _topSet->registerMetric(*_filestorMetrics);
 
     _bucketManagerMetrics = std::make_shared<BucketManagerMetrics>(_node->getComponentRegister().getBucketSpaceRepo());
-    _bucketManagerMetrics->setDisks(diskCount);
     _topSet->registerMetric(*_bucketManagerMetrics);
 
     _visitorMetrics = std::make_shared<VisitorMetrics>();
@@ -127,16 +125,16 @@ void MetricsTest::createFakeLoad()
     _clock->addSecondsToTime(1);
     _metricManager->timeChangedNotification();
     uint32_t n = 5;
-    for (uint32_t i=0; i<_bucketManagerMetrics->disks.size(); ++i) {
-        DataStoredMetrics& metrics(*_bucketManagerMetrics->disks[i]);
+    {
+        DataStoredMetrics& metrics(*_bucketManagerMetrics->disk);
         metrics.docs.inc(10 * n);
         metrics.bytes.inc(10240 * n);
     }
     _filestorMetrics->directoryEvents.inc(5);
     _filestorMetrics->partitionEvents.inc(4);
     _filestorMetrics->diskEvents.inc(3);
-    for (uint32_t i=0; i<_filestorMetrics->disks.size(); ++i) {
-        FileStorDiskMetrics& disk(*_filestorMetrics->disks[i]);
+    {
+        FileStorDiskMetrics& disk(*_filestorMetrics->disk);
         disk.queueSize.addValue(4 * n);
         //disk.averageQueueWaitingTime[documentapi::LoadType::DEFAULT].addValue(10 * n);
         disk.pendingMerges.addValue(4 * n);
@@ -238,7 +236,7 @@ TEST_F(MetricsTest, filestor_metrics) {
 }
 
 TEST_F(MetricsTest, snapshot_presenting) {
-    FileStorDiskMetrics& disk0(*_filestorMetrics->disks[0]);
+    FileStorDiskMetrics& disk0(*_filestorMetrics->disk);
     FileStorThreadMetrics& thread0(*disk0.threads[0]);
 
     LOG(debug, "Adding to get metric");
@@ -324,7 +322,7 @@ MetricsTest::createSnapshotForPeriod(std::chrono::seconds secs)
 }
 
 TEST_F(MetricsTest, current_gauge_values_override_snapshot_values) {
-    auto& metrics(*_bucketManagerMetrics->disks[0]);
+    auto& metrics(*_bucketManagerMetrics->disk);
     metrics.docs.set(1000);
     // Take a 5 minute snapshot of active metrics (1000 docs).
     createSnapshotForPeriod(5min);
diff --git a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
index 7876f19b3ba..8b70a47b4eb 100644
--- a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
+++ b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
@@ -163,7 +163,7 @@ struct FileStorManagerTest : Test{
                                  const Metric& metric);
 
     auto& thread_metrics_of(FileStorManager& manager) {
-        return manager._metrics->disks[0]->threads[0];
+        return manager._metrics->disk->threads[0];
     }
 };
 
@@ -392,7 +392,7 @@ TEST_F(FileStorManagerTest, handler_priority) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50ms);
@@ -499,7 +499,7 @@ TEST_F(FileStorManagerTest, handler_paused_multi_thread) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50ms);
@@ -545,7 +545,7 @@ TEST_F(FileStorManagerTest, handler_pause) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50ms);
@@ -591,7 +591,7 @@ TEST_F(FileStorManagerTest, remap_split) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50ms);
@@ -649,7 +649,7 @@ TEST_F(FileStorManagerTest, handler_timeout) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(),1,  1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(),1,  1);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     filestorHandler.setGetNextMessageTimeout(50ms);
@@ -709,18 +709,18 @@ TEST_F(FileStorManagerTest, priority) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(),1,  2);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(),1,  2);
 
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     std::unique_ptr<DiskThread> thread(createThread(persistenceHandler, filestorHandler, component));
 
     PersistenceHandler persistenceHandler2(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                           filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[1]);
+                                           filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[1]);
     std::unique_ptr<DiskThread> thread2(createThread(persistenceHandler2, filestorHandler, component));
 
     // Creating documents to test with. Different gids, 2 locations.
@@ -776,8 +776,8 @@ TEST_F(FileStorManagerTest, priority) {
 
     // Verify that thread 1 gets documents over 50 pri
     EXPECT_EQ(documents.size(),
-              metrics.disks[0]->threads[0]->operations.getValue()
-              + metrics.disks[0]->threads[1]->operations.getValue());
+              metrics.disk->threads[0]->operations.getValue()
+              + metrics.disk->threads[1]->operations.getValue());
     // Closing file stor handler before threads are deleted, such that
     // file stor threads getNextMessage calls returns.
     filestorHandler.close();
@@ -794,13 +794,13 @@ TEST_F(FileStorManagerTest, split1) {
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     std::unique_ptr<DiskThread> thread(createThread(persistenceHandler, filestorHandler, component));
     // Creating documents to test with. Different gids, 2 locations.
     std::vector<document::Document::SP > documents;
@@ -934,14 +934,14 @@ TEST_F(FileStorManagerTest, split_single_group) {
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(),1,  1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(),1,  1);
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     spi::Context context(defaultLoadType, spi::Priority(0), spi::Trace::TraceLevel(0));
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     for (uint32_t j=0; j<1; ++j) {
         // Test this twice, once where all the data ends up in file with
         // splitbit set, and once where all the data ends up in file with
@@ -1049,13 +1049,13 @@ TEST_F(FileStorManagerTest, split_empty_target_with_remapped_ops) {
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     std::unique_ptr<DiskThread> thread(createThread(persistenceHandler, filestorHandler, component));
 
     document::BucketId source(16, 0x10001);
@@ -1117,13 +1117,13 @@ TEST_F(FileStorManagerTest, notify_on_split_source_ownership_changed) {
     ForwardingMessageSender messageSender(*dummyManager);
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     std::unique_ptr<DiskThread> thread(createThread(persistenceHandler, filestorHandler, component));
 
     document::BucketId source(getFirstBucketNotOwnedByDistributor(0));
@@ -1160,13 +1160,13 @@ TEST_F(FileStorManagerTest, join) {
 
     documentapi::LoadTypeSet loadTypes("raw:");
     FileStorMetrics metrics(loadTypes.getMetricLoadTypes());
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
     FileStorHandlerImpl filestorHandler(messageSender, metrics, _node->getComponentRegister());
     ServiceLayerComponent component(_node->getComponentRegister(), "test");
     BucketOwnershipNotifier bucketOwnershipNotifier(component, messageSender);
     vespa::config::content::StorFilestorConfig cfg;
     PersistenceHandler persistenceHandler(_node->executor(), component, cfg, _node->getPersistenceProvider(),
-                                          filestorHandler, bucketOwnershipNotifier, *metrics.disks[0]->threads[0]);
+                                          filestorHandler, bucketOwnershipNotifier, *metrics.disk->threads[0]);
     std::unique_ptr<DiskThread> thread(createThread(persistenceHandler, filestorHandler, component));
     // Creating documents to test with. Different gids, 2 locations.
     std::vector<document::Document::SP > documents;
diff --git a/storage/src/tests/persistence/persistencequeuetest.cpp b/storage/src/tests/persistence/persistencequeuetest.cpp
index a19d060474b..61c6e446517 100644
--- a/storage/src/tests/persistence/persistencequeuetest.cpp
+++ b/storage/src/tests/persistence/persistencequeuetest.cpp
@@ -48,7 +48,7 @@ PersistenceQueueTest::Fixture::Fixture(FileStorTestFixture& parent_)
     top.push_back(std::move(dummyManager));
     top.open();
 
-    metrics.initDiskMetrics(1u, loadTypes.getMetricLoadTypes(), 1, 1);
+    metrics.initDiskMetrics(loadTypes.getMetricLoadTypes(), 1, 1);
 
     filestorHandler = std::make_unique<FileStorHandlerImpl>(messageSender, metrics,
                                                             parent._node->getComponentRegister());
diff --git a/storage/src/tests/persistence/persistencetestutils.cpp b/storage/src/tests/persistence/persistencetestutils.cpp
index b393c4a5f8d..489f58fbcc0 100644
--- a/storage/src/tests/persistence/persistencetestutils.cpp
+++ b/storage/src/tests/persistence/persistencetestutils.cpp
@@ -56,10 +56,10 @@ PersistenceTestEnvironment::PersistenceTestEnvironment(const std::string & rootO
       _metrics(_component.getLoadTypes()->getMetricLoadTypes())
 {
     _node.setupDummyPersistence();
-    _metrics.initDiskMetrics(1, _node.getLoadTypes()->getMetricLoadTypes(), 1, 1);
+    _metrics.initDiskMetrics(_node.getLoadTypes()->getMetricLoadTypes(), 1, 1);
     _handler = std::make_unique<FileStorHandlerImpl>(_messageKeeper, _metrics, _node.getComponentRegister());
     _diskEnv = std::make_unique<PersistenceUtil>(_component, *_handler,
-                                                 *_metrics.disks[0]->threads[0], _node.getPersistenceProvider());
+                                                 *_metrics.disk->threads[0], _node.getPersistenceProvider());
 }
 
 PersistenceTestEnvironment::~PersistenceTestEnvironment() {
diff --git a/storage/src/tests/storageserver/statereportertest.cpp b/storage/src/tests/storageserver/statereportertest.cpp
index 728bbb7a473..c67598dc37b 100644
--- a/storage/src/tests/storageserver/statereportertest.cpp
+++ b/storage/src/tests/storageserver/statereportertest.cpp
@@ -89,11 +89,10 @@ void StateReporterTest::SetUp() {
             _generationFetcher,
             "status");
 
-    uint16_t diskCount = 1u;
     documentapi::LoadTypeSet::SP loadTypes(_node->getLoadTypes());
 
     _filestorMetrics = std::make_shared<FileStorMetrics>(_node->getLoadTypes()->getMetricLoadTypes());
-    _filestorMetrics->initDiskMetrics(diskCount, loadTypes->getMetricLoadTypes(), 1, 1);
+    _filestorMetrics->initDiskMetrics(loadTypes->getMetricLoadTypes(), 1, 1);
     _topSet->registerMetric(*_filestorMetrics);
 
     _metricManager->init(_config->getConfigId(), _node->getThreadPool());
@@ -218,7 +217,7 @@ TEST_F(StateReporterTest, report_health) {
 }
 
 TEST_F(StateReporterTest, report_metrics) {
-    FileStorDiskMetrics& disk0(*_filestorMetrics->disks[0]);
+    FileStorDiskMetrics& disk0(*_filestorMetrics->disk);
     FileStorThreadMetrics& thread0(*disk0.threads[0]);
 
     LOG(debug, "Adding to get metric");
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
index a63067ca156..392c2da871a 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketmanager.cpp
@@ -50,7 +50,6 @@ BucketManager::BucketManager(const config::ConfigUri & configUri,
       _metrics(std::make_shared<BucketManagerMetrics>(_component.getBucketSpaceRepo())),
       _simulated_processing_delay(0)
 {
-    _metrics->setDisks(1);
     _component.registerStatusPage(*this);
     _component.registerMetric(*_metrics);
     _component.registerMetricUpdateHook(*this, framework::SecondTime(300));
@@ -232,7 +231,6 @@ BucketManager::updateMetrics(bool updateDocCount)
         _doneInitialized ? "" : ", server is not done initializing");
 
     const uint16_t diskCount = 1;
-    assert(diskCount >= 1);
     if (!updateDocCount || _doneInitialized) {
         MetricsUpdater total(diskCount);
         for (auto& space : _component.getBucketSpaceRepo()) {
@@ -253,13 +251,13 @@ BucketManager::updateMetrics(bool updateDocCount)
             }
         }
         if (updateDocCount) {
-            for (uint16_t i = 0; i< diskCount; i++) {
-                _metrics->disks[i]->buckets.addValue(total.disk[i].buckets);
-                _metrics->disks[i]->docs.addValue(total.disk[i].docs);
-                _metrics->disks[i]->bytes.addValue(total.disk[i].bytes);
-                _metrics->disks[i]->active.addValue(total.disk[i].active);
-                _metrics->disks[i]->ready.addValue(total.disk[i].ready);
-            }
+            auto & dest = *_metrics->disk;
+            const auto & src = total.disk[0];
+            dest.buckets.addValue(src.buckets);
+            dest.docs.addValue(src.docs);
+            dest.bytes.addValue(src.bytes);
+            dest.active.addValue(src.active);
+            dest.ready.addValue(src.ready);
         }
     }
     update_bucket_db_memory_usage_metrics();
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
index 2c1c5379dd9..b6d09679aee 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
+++ b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.cpp
@@ -43,7 +43,7 @@ BucketSpaceMetrics::~BucketSpaceMetrics() = default;
 
 BucketManagerMetrics::BucketManagerMetrics(const ContentBucketSpaceRepo& repo)
     : metrics::MetricSet("datastored", {}, ""),
-      disks(),
+      disk(std::make_shared<DataStoredMetrics>("disk0", this)),
       bucket_spaces(),
       total("alldisks", {{"sum"}}, "Sum of data stored metrics for all disks", this),
       simpleBucketInfoRequestSize("simplebucketinforeqsize", {},
@@ -58,20 +58,9 @@ BucketManagerMetrics::BucketManagerMetrics(const ContentBucketSpaceRepo& repo)
         bucket_spaces.emplace(space.first, std::make_unique<BucketSpaceMetrics>(
                 document::FixedBucketSpaces::to_string(space.first), this));
     }
+    total.addMetricToSum(*disk);
 }
 
 BucketManagerMetrics::~BucketManagerMetrics() = default;
 
-void
-BucketManagerMetrics::setDisks(uint16_t numDisks) {
-    assert(numDisks > 0);
-    if (!disks.empty()) {
-        throw IllegalStateException("Cannot initialize disks twice", VESPA_STRLOC);
-    }
-    for (uint16_t i = 0; i<numDisks; i++) {
-        disks.push_back(std::make_shared<DataStoredMetrics>(make_string("disk%d", i), this));
-        total.addMetricToSum(*disks.back());
-    }
-}
-
 }
diff --git a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.h b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.h
index 015efbcdc5c..e475252f23a 100644
--- a/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.h
+++ b/storage/src/vespa/storage/bucketdb/bucketmanagermetrics.h
@@ -48,7 +48,7 @@ class ContentBucketSpaceRepo;
 
 class BucketManagerMetrics : public metrics::MetricSet {
 public:
-    std::vector<std::shared_ptr<DataStoredMetrics>> disks;
+    std::shared_ptr<DataStoredMetrics> disk;
     using BucketSpaceMap = std::unordered_map<document::BucketSpace, std::unique_ptr<BucketSpaceMetrics>, document::BucketSpace::hash>;
     BucketSpaceMap bucket_spaces;
     metrics::SumMetric<metrics::MetricSet> total;
@@ -58,7 +58,6 @@ public:
 
     explicit BucketManagerMetrics(const ContentBucketSpaceRepo& repo);
     ~BucketManagerMetrics() override;
-    void setDisks(uint16_t numDisks);
 };
 
 }
diff --git a/storage/src/vespa/storage/config/stor-communicationmanager.def b/storage/src/vespa/storage/config/stor-communicationmanager.def
index 3511899728d..adb50465adc 100644
--- a/storage/src/vespa/storage/config/stor-communicationmanager.def
+++ b/storage/src/vespa/storage/config/stor-communicationmanager.def
@@ -69,7 +69,7 @@ rpc.num_network_threads int default=1
 ## This ensures the same RPC target is used for all messages to the same bucket to the same node,
 ## and the RPC target itself handles sequencing of these messages.
 ## NB !! It is vital that this number is kept in sync with stor-filestor:num_network_threads.
-## Only skilled vespa core devolpers should touch this.
+## Only skilled vespa core developers should touch this.
 rpc.num_targets_per_node int default=1
 
 # Minimum size of packets to compress (0 means no compression)
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
index 57d09818ae6..0c34a421c06 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestorhandlerimpl.cpp
@@ -62,7 +62,7 @@ FileStorHandlerImpl::FileStorHandlerImpl(uint32_t numThreads, uint32_t numStripe
         _stripes.emplace_back(*this, sender);
     }
 
-    _metrics = metrics.disks[0].get();
+    _metrics = metrics.disk.get();
     assert(_metrics != nullptr);
     uint32_t j(0);
     for (Stripe & stripe : _stripes) {
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
index 4b5e25e20a2..3269a05b3c2 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
@@ -129,11 +129,11 @@ FileStorManager::createRegisteredHandler(const ServiceLayerComponent & component
 {
     std::lock_guard guard(_lock);
     size_t index = _persistenceHandlers.size();
-    assert(index < _metrics->disks[0]->threads.size());
+    assert(index < _metrics->disk->threads.size());
     _persistenceHandlers.push_back(
             std::make_unique<PersistenceHandler>(*_sequencedExecutor, component,
                                                  *_config, *_provider, *_filestorHandler,
-                                                 *_bucketOwnershipNotifier, *_metrics->disks[0]->threads[index]));
+                                                 *_bucketOwnershipNotifier, *_metrics->disk->threads[index]));
     return *_persistenceHandlers.back();
 }
 
@@ -161,7 +161,7 @@ FileStorManager::configure(std::unique_ptr<vespa::config::content::StorFilestorC
         _config = std::move(config);
         size_t numThreads = _config->numThreads;
         size_t numStripes = std::max(size_t(1u), numThreads / 2);
-        _metrics->initDiskMetrics(1, _component.getLoadTypes()->getMetricLoadTypes(), numStripes,
+        _metrics->initDiskMetrics(_component.getLoadTypes()->getMetricLoadTypes(), numStripes,
                                   numThreads + _config->numResponseThreads + _config->numNetworkThreads);
 
         _filestorHandler = std::make_unique<FileStorHandlerImpl>(numThreads, numStripes, *this, *_metrics, _compReg);
@@ -259,30 +259,28 @@ FileStorManager::mapOperationToBucketAndDisk(api::BucketCommand& cmd, const docu
 }
 
 bool
-FileStorManager::handlePersistenceMessage( const shared_ptr<api::StorageMessage>& msg)
+FileStorManager::handlePersistenceMessage(const shared_ptr<api::StorageMessage>& msg)
 {
     api::ReturnCode errorCode(api::ReturnCode::OK);
-    do {
-        LOG(spam, "Received %s. Attempting to queue it.", msg->getType().getName().c_str());
+    LOG(spam, "Received %s. Attempting to queue it.", msg->getType().getName().c_str());
 
-        if (_filestorHandler->schedule(msg)) {
-            LOG(spam, "Received persistence message %s. Queued it to disk",
-                msg->getType().getName().c_str());
-            return true;
-        }
-        switch (_filestorHandler->getDiskState()) {
-            case FileStorHandler::DISABLED:
-                errorCode = api::ReturnCode(api::ReturnCode::DISK_FAILURE, "Disk disabled");
-                break;
-            case FileStorHandler::CLOSED:
-                errorCode = api::ReturnCode(api::ReturnCode::ABORTED, "Shutting down storage node.");
-                break;
-            case FileStorHandler::AVAILABLE:
-                assert(false);
-        }
-    } while (false);
-        // If we get here, we failed to schedule message. errorCode says why
-        // We need to reply to message (while not having bucket lock)
+    if (_filestorHandler->schedule(msg)) {
+        LOG(spam, "Received persistence message %s. Queued it to disk",
+            msg->getType().getName().c_str());
+        return true;
+    }
+    switch (_filestorHandler->getDiskState()) {
+        case FileStorHandler::DISABLED:
+            errorCode = api::ReturnCode(api::ReturnCode::DISK_FAILURE, "Disk disabled");
+            break;
+        case FileStorHandler::CLOSED:
+            errorCode = api::ReturnCode(api::ReturnCode::ABORTED, "Shutting down storage node.");
+            break;
+        case FileStorHandler::AVAILABLE:
+            assert(false);
+    }
+    // If we get here, we failed to schedule message. errorCode says why
+    // We need to reply to message (while not having bucket lock)
     if (!msg->getType().isReply()) {
         std::shared_ptr<api::StorageReply> reply = static_cast<api::StorageCommand&>(*msg).makeReply();
         reply->setResult(errorCode);
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
index 6e0c474d9ba..ed42f1932eb 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.cpp
@@ -262,24 +262,14 @@ FileStorMetrics::FileStorMetrics(const LoadTypeSet&)
 
 FileStorMetrics::~FileStorMetrics() = default;
 
-void FileStorMetrics::initDiskMetrics(uint16_t numDisks, const LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk)
+void FileStorMetrics::initDiskMetrics(const LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk)
 {
-    if (!disks.empty()) {
-        throw vespalib::IllegalStateException("Can't initialize disks twice", VESPA_STRLOC);
-    }
-    disks.clear();
-    disks.resize(numDisks);
-    for (uint32_t i=0; i<numDisks; ++i) {
-        // Currently FileStorHandlerImpl expects metrics to exist for
-        // disks that are not in use too.
-        std::ostringstream desc;
-        std::ostringstream name;
-        name << "disk_" << i;
-        desc << "Disk " << i;
-        disks[i] = std::make_shared<FileStorDiskMetrics>( name.str(), desc.str(), loadTypes, this);
-        sum.addMetricToSum(*disks[i]);
-        disks[i]->initDiskMetrics(loadTypes, numStripes, threadsPerDisk);
-    }
+    assert( ! disk);
+    // Currently FileStorHandlerImpl expects metrics to exist for
+    // disks that are not in use too.
+    disk = std::make_shared<FileStorDiskMetrics>( "disk_0", "Disk 0", loadTypes, this);
+    sum.addMetricToSum(*disk);
+    disk->initDiskMetrics(loadTypes, numStripes, threadsPerDisk);
 }
 
 }
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
index ee82e17e7b3..86daf022fb2 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormetrics.h
@@ -159,7 +159,7 @@ public:
 
 struct FileStorMetrics : public metrics::MetricSet
 {
-    std::vector<FileStorDiskMetrics::SP> disks;
+    FileStorDiskMetrics::SP disk;
     metrics::SumMetric<MetricSet> sum;
     metrics::LongCountMetric directoryEvents;
     metrics::LongCountMetric partitionEvents;
@@ -169,7 +169,7 @@ struct FileStorMetrics : public metrics::MetricSet
     explicit FileStorMetrics(const metrics::LoadTypeSet&);
     ~FileStorMetrics() override;
 
-    void initDiskMetrics(uint16_t numDisks, const metrics::LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk);
+    void initDiskMetrics(const metrics::LoadTypeSet& loadTypes, uint32_t numStripes, uint32_t threadsPerDisk);
 };
 
 }