Merge pull request #29269 from vespa-engine/geirst/control-resource-usage-when-in-maintenance

Control resource usage when node in maintenance

17 files changed, 110 insertions, 78 deletions

diff --git a/searchcore/src/tests/proton/documentdb/clusterstatehandler/CMakeLists.txt b/searchcore/src/tests/proton/documentdb/clusterstatehandler/CMakeLists.txt
index 0b42d480e33..b89d4d9301f 100644
--- a/searchcore/src/tests/proton/documentdb/clusterstatehandler/CMakeLists.txt
+++ b/searchcore/src/tests/proton/documentdb/clusterstatehandler/CMakeLists.txt
@@ -10,5 +10,6 @@ vespa_add_executable(searchcore_clusterstatehandler_test_app TEST
     searchcore_attribute
     searchcore_pcommon
     searchcore_grouping
+    GTest::GTest
 )
 vespa_add_test(NAME searchcore_clusterstatehandler_test_app COMMAND searchcore_clusterstatehandler_test_app)
diff --git a/searchcore/src/tests/proton/documentdb/clusterstatehandler/clusterstatehandler_test.cpp b/searchcore/src/tests/proton/documentdb/clusterstatehandler/clusterstatehandler_test.cpp
index 4cd2eab513c..539ee9ce3aa 100644
--- a/searchcore/src/tests/proton/documentdb/clusterstatehandler/clusterstatehandler_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/clusterstatehandler/clusterstatehandler_test.cpp
@@ -1,11 +1,12 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+
 #include <vespa/searchcore/proton/server/clusterstatehandler.h>
 #include <vespa/searchcore/proton/server/iclusterstatechangedhandler.h>
 #include <vespa/searchcore/proton/test/test.h>
-#include <vespa/vespalib/util/threadstackexecutor.h>
-#include <vespa/vespalib/testkit/testapp.h>
 #include <vespa/vdslib/distribution/distribution.h>
 #include <vespa/vdslib/state/clusterstate.h>
+#include <vespa/vespalib/gtest/gtest.h>
+#include <vespa/vespalib/util/threadstackexecutor.h>
 
 #include <vespa/log/log.h>
 LOG_SETUP("cluster_state_handler_test");
@@ -17,8 +18,7 @@ using storage::spi::BucketIdListResult;
 using storage::spi::ClusterState;
 using storage::spi::Result;
 
-struct MyClusterStateChangedHandler : public IClusterStateChangedHandler
-{
+struct MyClusterStateChangedHandler : public IClusterStateChangedHandler {
     std::shared_ptr<IBucketStateCalculator> _calc;
     void
     notifyClusterStateChanged(const std::shared_ptr<IBucketStateCalculator> &newCalc) override {
@@ -26,23 +26,26 @@ struct MyClusterStateChangedHandler : public IClusterStateChangedHandler
     }
 };
 
-
 BucketId bucket1(1);
 BucketId bucket2(2);
 BucketId bucket3(3);
 Distribution distribution(Distribution::getDefaultDistributionConfig(3, 3));
-storage::lib::ClusterState rawClusterState("version:1 storage:3 distributor:3");
-ClusterState clusterState(rawClusterState, 0, distribution);
 
+ClusterState make_cluster_state(const vespalib::string& state, uint16_t node_index, bool maintenance_in_all_spaces = false) {
+    return ClusterState(storage::lib::ClusterState(state), node_index, distribution, maintenance_in_all_spaces);
+}
 
-struct Fixture
-{
+ClusterState basic_state = make_cluster_state("distributor:3 storage:3", 0);
+ClusterState node_retired_state = make_cluster_state("distributor:3 .1.s:d storage:3 .1.s:r", 1);
+ClusterState node_maintenance_state = make_cluster_state("distributor:3 storage:3", 1, true);
+
+struct ClusterStateHandlerTest : testing::Test {
     vespalib::ThreadStackExecutor   _exec;
     ClusterStateHandler             _stateHandler;
     MyClusterStateChangedHandler    _changedHandler;
     test::GenericResultHandler      _genericHandler;
     test::BucketIdListResultHandler _bucketListHandler;
-    Fixture()
+    ClusterStateHandlerTest()
         : _exec(1),
           _stateHandler(_exec),
           _changedHandler(),
@@ -51,47 +54,66 @@ struct Fixture
     {
         _stateHandler.addClusterStateChangedHandler(&_changedHandler);
     }
-    ~Fixture()
-    {
+    ~ClusterStateHandlerTest() {
         _stateHandler.removeClusterStateChangedHandler(&_changedHandler);
     }
+    const IBucketStateCalculator& set_cluster_state(const ClusterState& state) {
+        _stateHandler.handleSetClusterState(state, _genericHandler);
+        _exec.sync();
+        EXPECT_TRUE(_changedHandler._calc);
+        return *_changedHandler._calc;
+    }
 };
 
+TEST_F(ClusterStateHandlerTest, cluster_state_change_is_notified)
+{
+    const auto& calc = set_cluster_state(basic_state);
+    EXPECT_TRUE(calc.clusterUp());
+    EXPECT_TRUE(calc.nodeUp());
+    EXPECT_FALSE(calc.nodeInitializing());
+    EXPECT_FALSE(calc.nodeRetired());
+    EXPECT_FALSE(calc.nodeMaintenance());
+    EXPECT_FALSE(calc.node_retired_or_maintenance());
+}
 
-TEST_F("require that cluster state change is notified", Fixture)
+TEST_F(ClusterStateHandlerTest, node_in_retired_state)
 {
-    f._stateHandler.handleSetClusterState(clusterState, f._genericHandler);
-    f._exec.sync();
-    EXPECT_TRUE(f._changedHandler._calc);
+    const auto &calc = set_cluster_state(node_retired_state);
+    EXPECT_TRUE(calc.nodeRetired());
+    EXPECT_FALSE(calc.nodeMaintenance());
+    EXPECT_TRUE(calc.node_retired_or_maintenance());
 }
 
+TEST_F(ClusterStateHandlerTest, node_in_maintenance_state)
+{
+    const auto &calc = set_cluster_state(node_maintenance_state);
+    EXPECT_FALSE(calc.nodeRetired());
+    EXPECT_TRUE(calc.nodeMaintenance());
+    EXPECT_TRUE(calc.node_retired_or_maintenance());
+}
 
-TEST_F("require that modified buckets are returned", Fixture)
+TEST_F(ClusterStateHandlerTest, modified_buckets_are_returned)
 {
-    f._stateHandler.handleSetClusterState(clusterState, f._genericHandler);
-    f._exec.sync();
+    _stateHandler.handleSetClusterState(basic_state, _genericHandler);
+    _exec.sync();
 
     // notify 2 buckets
-    IBucketModifiedHandler &bmh = f._stateHandler;
+    IBucketModifiedHandler &bmh = _stateHandler;
     bmh.notifyBucketModified(bucket1);
     bmh.notifyBucketModified(bucket2);
-    f._stateHandler.handleGetModifiedBuckets(f._bucketListHandler);
-    f._exec.sync();
-    EXPECT_EQUAL(2u, f._bucketListHandler.getList().size());
-    EXPECT_EQUAL(bucket1, f._bucketListHandler.getList()[0]);
-    EXPECT_EQUAL(bucket2, f._bucketListHandler.getList()[1]);
+    _stateHandler.handleGetModifiedBuckets(_bucketListHandler);
+    _exec.sync();
+    EXPECT_EQ(2u, _bucketListHandler.getList().size());
+    EXPECT_EQ(bucket1, _bucketListHandler.getList()[0]);
+    EXPECT_EQ(bucket2, _bucketListHandler.getList()[1]);
 
     // notify 1 bucket, already reported buckets should be gone
     bmh.notifyBucketModified(bucket3);
-    f._stateHandler.handleGetModifiedBuckets(f._bucketListHandler);
-    f._exec.sync();
-    EXPECT_EQUAL(1u, f._bucketListHandler.getList().size());
-    EXPECT_EQUAL(bucket3, f._bucketListHandler.getList()[0]);
+    _stateHandler.handleGetModifiedBuckets(_bucketListHandler);
+    _exec.sync();
+    EXPECT_EQ(1u, _bucketListHandler.getList().size());
+    EXPECT_EQ(bucket3, _bucketListHandler.getList()[0]);
 }
 
-
-TEST_MAIN()
-{
-    TEST_RUN_ALL();
-}
+GTEST_MAIN_RUN_ALL_TESTS()
 
diff --git a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
index b5096a4c046..596ebb933a4 100644
--- a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
@@ -620,30 +620,35 @@ TEST_F("require that attribute manager can be reconfigured", SearchableFixture)
     requireThatAttributeManagerCanBeReconfigured(f);
 }
 
-TEST_F("require that subdb reflect retirement", FastAccessFixture)
+TEST_F("require that subdb reflect retirement or maintenance", FastAccessFixture)
 {
     CompactionStrategy cfg(0.1, 0.3);
 
-    EXPECT_FALSE(f._subDb.isNodeRetired());
+    EXPECT_FALSE(f._subDb.is_node_retired_or_maintenance());
     auto unretired_cfg = f._subDb.computeCompactionStrategy(cfg);
     EXPECT_TRUE(cfg == unretired_cfg);
 
     auto calc = std::make_shared<proton::test::BucketStateCalculator>();
     calc->setNodeRetired(true);
     f.setBucketStateCalculator(calc);
-    EXPECT_TRUE(f._subDb.isNodeRetired());
+    EXPECT_TRUE(f._subDb.is_node_retired_or_maintenance());
     auto retired_cfg = f._subDb.computeCompactionStrategy(cfg);
     EXPECT_TRUE(cfg != retired_cfg);
     EXPECT_TRUE(CompactionStrategy(0.5, 0.5) == retired_cfg);
 
     calc->setNodeRetired(false);
+    calc->setNodeMaintenance(true);
     f.setBucketStateCalculator(calc);
-    EXPECT_FALSE(f._subDb.isNodeRetired());
+    EXPECT_TRUE(f._subDb.is_node_retired_or_maintenance());
+
+    calc->setNodeMaintenance(false);
+    f.setBucketStateCalculator(calc);
+    EXPECT_FALSE(f._subDb.is_node_retired_or_maintenance());
     unretired_cfg = f._subDb.computeCompactionStrategy(cfg);
     EXPECT_TRUE(cfg == unretired_cfg);
 }
 
-TEST_F("require that attribute compaction config reflect retirement", FastAccessFixture) {
+TEST_F("require that attribute compaction config reflect retirement or maintenance", FastAccessFixture) {
     CompactionStrategy default_cfg(0.05, 0.2);
     CompactionStrategy retired_cfg(0.5, 0.5);
 
diff --git a/searchcore/src/tests/proton/documentdb/lid_space_compaction/lid_space_jobtest.cpp b/searchcore/src/tests/proton/documentdb/lid_space_compaction/lid_space_jobtest.cpp
index d4d2a6dc377..eea523870c3 100644
--- a/searchcore/src/tests/proton/documentdb/lid_space_compaction/lid_space_jobtest.cpp
+++ b/searchcore/src/tests/proton/documentdb/lid_space_compaction/lid_space_jobtest.cpp
@@ -44,7 +44,7 @@ JobTestBase::init(uint32_t allowedLidBloat,
           double allowedLidBloatFactor,
           double resourceLimitFactor,
           vespalib::duration interval,
-          bool nodeRetired,
+          bool node_retired_or_maintenance,
           uint32_t maxOutstandingMoveOps)
 {
     _handler = std::make_shared<MyHandler>(maxOutstandingMoveOps != MAX_OUTSTANDING_MOVE_OPS, true);
@@ -57,7 +57,7 @@ JobTestBase::init(uint32_t allowedLidBloat,
     _master = std::make_unique<proton::SyncableExecutorThreadService> (*_singleExecutor);
     _bucketExecutor = std::make_unique<storage::spi::dummy::DummyBucketExecutor>(4);
     _job = lidspace::CompactionJob::create(compactCfg, RetainGuard(_refCount), _handler, _storer, *_master, *_bucketExecutor,
-                                           _diskMemUsageNotifier, blockableCfg, _clusterStateHandler, nodeRetired,
+                                           _diskMemUsageNotifier, blockableCfg, _clusterStateHandler, node_retired_or_maintenance,
                                            document::BucketSpace::placeHolder());
 }
 
@@ -180,10 +180,10 @@ JobTest::init(uint32_t allowedLidBloat,
               double allowedLidBloatFactor,
               double resourceLimitFactor,
               vespalib::duration interval,
-              bool nodeRetired,
+              bool node_retired_or_maintenance,
               uint32_t maxOutstandingMoveOps)
 {
-    JobTestBase::init(allowedLidBloat, allowedLidBloatFactor, resourceLimitFactor, interval, nodeRetired, maxOutstandingMoveOps);
+    JobTestBase::init(allowedLidBloat, allowedLidBloatFactor, resourceLimitFactor, interval, node_retired_or_maintenance, maxOutstandingMoveOps);
     _jobRunner = std::make_unique<MyDirectJobRunner>(*_job);
 }
 
diff --git a/searchcore/src/tests/proton/server/memory_flush_config_updater/memory_flush_config_updater_test.cpp b/searchcore/src/tests/proton/server/memory_flush_config_updater/memory_flush_config_updater_test.cpp
index ec135800fde..79b4b4a3627 100644
--- a/searchcore/src/tests/proton/server/memory_flush_config_updater/memory_flush_config_updater_test.cpp
+++ b/searchcore/src/tests/proton/server/memory_flush_config_updater/memory_flush_config_updater_test.cpp
@@ -69,8 +69,8 @@ struct Fixture
     void notifyDiskMemUsage(const ResourceUsageState &diskState, const ResourceUsageState &memoryState) {
         updater.notifyDiskMemUsage(DiskMemUsageState(diskState, memoryState));
     }
-    void setNodeRetired(bool nodeRetired) {
-        updater.setNodeRetired(nodeRetired);
+    void set_node_retired_or_maintenance(bool value) {
+        updater.set_node_retired_or_maintenance(value);
     }
 };
 
@@ -226,12 +226,12 @@ TEST_F("require that we must go below low watermark for memory usage before usin
     TEST_DO(f.assertStrategyConfig(4, 1, 20));
 }
 
-TEST_F("require that more disk bloat is allowed while node state is retired", Fixture)
+TEST_F("require that more disk bloat is allowed while node state is retired or maintenance", Fixture)
 {
     constexpr double DEFAULT_DISK_BLOAT = 0.25;
     f.notifyDiskMemUsage(ResourceUsageState(0.7, 0.3), belowLimit());
     TEST_DO(f.assertStrategyDiskConfig(DEFAULT_DISK_BLOAT, DEFAULT_DISK_BLOAT));
-    f.setNodeRetired(true);
+    f.set_node_retired_or_maintenance(true);
     TEST_DO(f.assertStrategyDiskConfig((0.8 - ((0.3/0.7)*(1 - DEFAULT_DISK_BLOAT))) / 0.8, 1.0));
     f.notifyDiskMemUsage(belowLimit(), belowLimit());
     TEST_DO(f.assertStrategyDiskConfig(DEFAULT_DISK_BLOAT, DEFAULT_DISK_BLOAT));
diff --git a/searchcore/src/vespa/searchcore/proton/server/clusterstatehandler.cpp b/searchcore/src/vespa/searchcore/proton/server/clusterstatehandler.cpp
index 0870d854234..34a57badd29 100644
--- a/searchcore/src/vespa/searchcore/proton/server/clusterstatehandler.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/clusterstatehandler.cpp
@@ -47,6 +47,7 @@ public:
     bool nodeInitializing() const override { return _nodeInitializing; }
     bool nodeRetired() const override { return _nodeRetired; }
     bool nodeMaintenance() const noexcept override { return _nodeMaintenance; }
+    bool node_retired_or_maintenance() const noexcept override { return _nodeRetired || _nodeMaintenance; }
 };
 
 }
diff --git a/searchcore/src/vespa/searchcore/proton/server/fast_access_doc_subdb.cpp b/searchcore/src/vespa/searchcore/proton/server/fast_access_doc_subdb.cpp
index 43bdc764a2f..a2d68ad8920 100644
--- a/searchcore/src/vespa/searchcore/proton/server/fast_access_doc_subdb.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/fast_access_doc_subdb.cpp
@@ -272,7 +272,7 @@ FastAccessDocSubDB::applyConfig(const DocumentDBConfig &newConfigSnapshot, const
             reconfigureAttributeMetrics(*newMgr, *oldMgr);
         }
         _iFeedView.set(_fastAccessFeedView.get());
-        if (isNodeRetired()) {
+        if (is_node_retired_or_maintenance()) {
             // TODO Should probably ahve a similar OnDone callback to applyConfig too.
             vespalib::Gate gate;
             reconfigureAttributesConsideringNodeState(std::make_shared<vespalib::GateCallback>(gate));
diff --git a/searchcore/src/vespa/searchcore/proton/server/ibucketstatecalculator.h b/searchcore/src/vespa/searchcore/proton/server/ibucketstatecalculator.h
index a2790979212..90277089034 100644
--- a/searchcore/src/vespa/searchcore/proton/server/ibucketstatecalculator.h
+++ b/searchcore/src/vespa/searchcore/proton/server/ibucketstatecalculator.h
@@ -16,6 +16,7 @@ struct IBucketStateCalculator
     virtual bool nodeInitializing() const = 0;
     virtual bool nodeRetired() const = 0;
     virtual bool nodeMaintenance() const noexcept = 0;
+    virtual bool node_retired_or_maintenance() const noexcept = 0;
     virtual ~IBucketStateCalculator() = default;
 };
 
diff --git a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp b/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp
index de583c0b36d..cedc24502fd 100644
--- a/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/lid_space_compaction_job.cpp
@@ -130,7 +130,7 @@ CompactionJob::CompactionJob(const DocumentDBLidSpaceCompactionConfig &config,
                              IDiskMemUsageNotifier &diskMemUsageNotifier,
                              const BlockableMaintenanceJobConfig &blockableConfig,
                              IClusterStateChangedNotifier &clusterStateChangedNotifier,
-                             bool nodeRetired,
+                             bool node_retired_or_maintenance,
                              document::BucketSpace bucketSpace)
     : BlockableMaintenanceJob("lid_space_compaction." + handler->getName(),
                               config.getDelay(), config.getInterval(), blockableConfig),
@@ -154,7 +154,7 @@ CompactionJob::CompactionJob(const DocumentDBLidSpaceCompactionConfig &config,
 {
     _diskMemUsageNotifier.addDiskMemUsageListener(this);
     _clusterStateChangedNotifier.addClusterStateChangedHandler(this);
-    if (nodeRetired) {
+    if (node_retired_or_maintenance) {
         setBlocked(BlockedReason::CLUSTER_STATE);
     }
     _handler->set_operation_listener(_ops_rate_tracker);
@@ -175,12 +175,12 @@ CompactionJob::create(const DocumentDBLidSpaceCompactionConfig &config,
                       IDiskMemUsageNotifier &diskMemUsageNotifier,
                       const BlockableMaintenanceJobConfig &blockableConfig,
                       IClusterStateChangedNotifier &clusterStateChangedNotifier,
-                      bool nodeRetired,
+                      bool node_retired_or_maintenance,
                       document::BucketSpace bucketSpace)
 {
     return std::shared_ptr<CompactionJob>(
             new CompactionJob(config, std::move(dbRetainer), std::move(handler), opStorer, master, bucketExecutor,
-                              diskMemUsageNotifier, blockableConfig, clusterStateChangedNotifier, nodeRetired, bucketSpace),
+                              diskMemUsageNotifier, blockableConfig, clusterStateChangedNotifier, node_retired_or_maintenance, bucketSpace),
             [&master](auto job) {
                 auto failed = master.execute(makeLambdaTask([job]() { delete job; }));
                 assert(!failed);
@@ -303,16 +303,16 @@ void
 CompactionJob::notifyClusterStateChanged(const std::shared_ptr<IBucketStateCalculator> &newCalc)
 {
     // Called by master write thread
-    bool nodeRetired = newCalc->nodeRetired();
-    if (!nodeRetired) {
+    bool node_retired_or_maintenance = newCalc->node_retired_or_maintenance();
+    if (!node_retired_or_maintenance) {
         if (isBlocked(BlockedReason::CLUSTER_STATE)) {
-            LOG(info, "%s: Lid space compaction is un-blocked as node is no longer retired", _handler->getName().c_str());
+            LOG(info, "%s: Lid space compaction is un-blocked as node is no longer retired or in maintenance", _handler->getName().c_str());
             unBlock(BlockedReason::CLUSTER_STATE);
         }
     } else if (!isBlocked(BlockedReason::CLUSTER_STATE)) {
-        LOG(info, "%s: Lid space compaction is blocked as node is retired", _handler->getName().c_str());
+        LOG(info, "%s: Lid space compaction is blocked as node is retired or in maintenance", _handler->getName().c_str());
         setBlocked(BlockedReason::CLUSTER_STATE);
     }
 }
 
-} // namespace proton
+}
diff --git a/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp b/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
index 3c66a695323..b9a0abb3c3d 100644
--- a/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/maintenance_jobs_injector.cpp
@@ -37,7 +37,7 @@ injectLidSpaceCompactionJobs(MaintenanceController &controller,
         auto job = lidspace::CompactionJob::create(config.getLidSpaceCompactionConfig(), controller.retainDB(),
                                                    std::move(lidHandler), opStorer, controller.masterThread(),
                                                    bucketExecutor, diskMemUsageNotifier,config.getBlockableJobConfig(),
-                                                   clusterStateChangedNotifier, calc && calc->nodeRetired(), bucketSpace);
+                                                   clusterStateChangedNotifier, calc && calc->node_retired_or_maintenance(), bucketSpace);
         controller.registerJob(trackJob(tracker, std::move(job)));
     }
 }
diff --git a/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.cpp b/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.cpp
index f941209ed1e..b2f40f1c37d 100644
--- a/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.cpp
@@ -34,7 +34,7 @@ MemoryFlushConfigUpdater::considerUseConservativeDiskMode(const LockGuard &guard
         _useConservativeDiskMode = true;
     } else {
         _useConservativeDiskMode = false;
-        if (_nodeRetired) {
+        if (_node_retired_or_maintenance) {
             considerUseRelaxedDiskMode(guard, newConfig);
         }
     }
@@ -81,9 +81,9 @@ MemoryFlushConfigUpdater::updateFlushStrategy(const LockGuard &guard, const char
     MemoryFlush::Config currentConfig = _flushStrategy->getConfig();
     if ( currentConfig != newConfig ) {
         _flushStrategy->setConfig(newConfig);
-        LOG(info, "Due to %s (conservative-disk=%d, conservative-memory=%d, retired=%d) flush config updated to "
+        LOG(info, "Due to %s (conservative-disk=%d, conservative-memory=%d, retired-or-maintenance=%d) flush config updated to "
                   "global-disk-bloat(%1.2f), max-tls-size(%" PRIu64 "),max-global-memory(%" PRIu64 "), max-memory-gain(%" PRIu64 ")",
-            why, _useConservativeDiskMode, _useConservativeMemoryMode, _nodeRetired,
+            why, _useConservativeDiskMode, _useConservativeMemoryMode, _node_retired_or_maintenance,
             newConfig.globalDiskBloatFactor, newConfig.maxGlobalTlsSize,
             newConfig.maxGlobalMemory, newConfig.maxMemoryGain);
         LOG(debug, "Old config = %s\nNew config = %s", currentConfig.toString().c_str(), newConfig.toString().c_str());
@@ -100,7 +100,7 @@ MemoryFlushConfigUpdater::MemoryFlushConfigUpdater(const MemoryFlush::SP &flushS
       _currState(),
       _useConservativeDiskMode(false),
       _useConservativeMemoryMode(false),
-      _nodeRetired(false)
+      _node_retired_or_maintenance(false)
 {
 }
 
@@ -121,11 +121,11 @@ MemoryFlushConfigUpdater::notifyDiskMemUsage(DiskMemUsageState newState)
 }
 
 void
-MemoryFlushConfigUpdater::setNodeRetired(bool nodeRetired)
+MemoryFlushConfigUpdater::set_node_retired_or_maintenance(bool value)
 {
     LockGuard guard(_mutex);
-    _nodeRetired = nodeRetired;
-    updateFlushStrategy(guard, nodeRetired ? "node retired" : "node unretired");
+    _node_retired_or_maintenance = value;
+    updateFlushStrategy(guard, value ? "node retired or in maintenance" : "node NOT retired or in maintenance");
 }
 
 namespace {
diff --git a/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.h b/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.h
index f97b232f13f..7508c2fb90a 100644
--- a/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.h
+++ b/searchcore/src/vespa/searchcore/proton/server/memory_flush_config_updater.h
@@ -28,7 +28,7 @@ private:
     DiskMemUsageState           _currState;
     bool                        _useConservativeDiskMode;
     bool                        _useConservativeMemoryMode;
-    bool                        _nodeRetired;
+    bool                        _node_retired_or_maintenance;
 
 
     void considerUseConservativeDiskMode(const LockGuard &guard, MemoryFlush::Config &newConfig);
@@ -43,7 +43,7 @@ public:
                              const ProtonConfig::Flush::Memory &config,
                              const vespalib::HwInfo::Memory &memory);
     void setConfig(const ProtonConfig::Flush::Memory &newConfig);
-    void setNodeRetired(bool nodeRetired);
+    void set_node_retired_or_maintenance(bool value);
     void notifyDiskMemUsage(DiskMemUsageState newState) override;
 
     static MemoryFlush::Config convertConfig(const ProtonConfig::Flush::Memory &config,
diff --git a/searchcore/src/vespa/searchcore/proton/server/proton.cpp b/searchcore/src/vespa/searchcore/proton/server/proton.cpp
index 2fb4d05c8b3..0839117f6ef 100644
--- a/searchcore/src/vespa/searchcore/proton/server/proton.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/proton.cpp
@@ -925,12 +925,13 @@ Proton::setClusterState(BucketSpace bucketSpace, const storage::spi::ClusterStat
     // about whether node is supposed to be up or not.  Match engine
     // needs to know this in order to stop serving queries.
     bool nodeUpInBucketSpace(calc.nodeUp()); // TODO rename calculator function to imply bucket space affinity
-    bool nodeRetired(calc.nodeRetired());
+    bool nodeRetired = calc.nodeRetired();
+    bool nodeMaintenance = calc.nodeMaintenance();
     bool nodeUp = updateNodeUp(bucketSpace, nodeUpInBucketSpace);
     _matchEngine->setNodeUp(nodeUp);
-    _matchEngine->setNodeMaintenance(calc.nodeMaintenance()); // Note: _all_ bucket spaces in maintenance
+    _matchEngine->setNodeMaintenance(nodeMaintenance); // Note: _all_ bucket spaces in maintenance
     if (_memoryFlushConfigUpdater) {
-        _memoryFlushConfigUpdater->setNodeRetired(nodeRetired);
+        _memoryFlushConfigUpdater->set_node_retired_or_maintenance(nodeRetired || nodeMaintenance);
     }
 }
 
diff --git a/searchcore/src/vespa/searchcore/proton/server/searchabledocsubdb.cpp b/searchcore/src/vespa/searchcore/proton/server/searchabledocsubdb.cpp
index 8d25a09b93c..ed9dfbfe578 100644
--- a/searchcore/src/vespa/searchcore/proton/server/searchabledocsubdb.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/searchabledocsubdb.cpp
@@ -183,7 +183,7 @@ SearchableDocSubDB::applyFlushConfig(const DocumentDBFlushConfig &flushConfig)
 void
 SearchableDocSubDB::propagateFlushConfig()
 {
-    uint32_t maxFlushed = isNodeRetired() ? _flushConfig.getMaxFlushedRetired() : _flushConfig.getMaxFlushed();
+    uint32_t maxFlushed = is_node_retired_or_maintenance() ? _flushConfig.getMaxFlushedRetired() : _flushConfig.getMaxFlushed();
     _indexMgr->setMaxFlushed(maxFlushed);
 }
 
diff --git a/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.cpp b/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.cpp
index 5aa0d926e45..0c217eeeeba 100644
--- a/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.cpp
+++ b/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.cpp
@@ -113,7 +113,7 @@ StoreOnlyDocSubDB::StoreOnlyDocSubDB(const Config &cfg, const Context &ctx)
       _dmsFlushTarget(),
       _dmsShrinkTarget(),
       _pendingLidsForCommit(std::make_shared<PendingLidTracker>()),
-      _nodeRetired(false),
+      _node_retired_or_maintenance(false),
       _lastConfiguredCompactionStrategy(),
       _subDbId(cfg._subDbId),
       _subDbType(cfg._subDbType),
@@ -472,7 +472,7 @@ struct UpdateConfig : public search::attribute::IAttributeFunctor {
 
 CompactionStrategy
 StoreOnlyDocSubDB::computeCompactionStrategy(CompactionStrategy strategy) const {
-    return isNodeRetired()
+    return is_node_retired_or_maintenance()
            ? CompactionStrategy(RETIRED_DEAD_RATIO, RETIRED_DEAD_RATIO)
            : strategy;
 }
@@ -493,9 +493,9 @@ StoreOnlyDocSubDB::reconfigure(const search::LogDocumentStore::Config & config,
 
 void
 StoreOnlyDocSubDB::setBucketStateCalculator(const std::shared_ptr<IBucketStateCalculator> & calc, OnDone onDone) {
-    bool wasNodeRetired = isNodeRetired();
-    _nodeRetired = calc->nodeRetired();
-    if (wasNodeRetired != isNodeRetired()) {
+    bool was_node_retired_or_maintenance = is_node_retired_or_maintenance();
+    _node_retired_or_maintenance = calc->node_retired_or_maintenance();
+    if (was_node_retired_or_maintenance != is_node_retired_or_maintenance()) {
         CompactionStrategy compactionStrategy = computeCompactionStrategy(_lastConfiguredCompactionStrategy);
         auto cfg = _dms->getConfig();
         cfg.setCompactionStrategy(compactionStrategy);
diff --git a/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.h b/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.h
index 2d8d517c4d5..d530e44755c 100644
--- a/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.h
+++ b/searchcore/src/vespa/searchcore/proton/server/storeonlydocsubdb.h
@@ -152,7 +152,7 @@ private:
     DocumentMetaStoreFlushTarget::SP           _dmsFlushTarget;
     std::shared_ptr<ShrinkLidSpaceFlushTarget> _dmsShrinkTarget;
     std::shared_ptr<PendingLidTrackerBase>     _pendingLidsForCommit;
-    bool                                       _nodeRetired;
+    bool                                       _node_retired_or_maintenance;
     vespalib::datastore::CompactionStrategy    _lastConfiguredCompactionStrategy;
 
     IFlushTargetList getFlushTargets() override;
@@ -239,7 +239,7 @@ public:
     void tearDownReferences(IDocumentDBReferenceResolver &resolver) override;
     PendingLidTrackerBase & getUncommittedLidsTracker() override { return *_pendingLidsForCommit; }
     vespalib::datastore::CompactionStrategy computeCompactionStrategy(vespalib::datastore::CompactionStrategy strategy) const;
-    bool isNodeRetired() const { return _nodeRetired; }
+    bool is_node_retired_or_maintenance() const { return _node_retired_or_maintenance; }
     TransientResourceUsage get_transient_resource_usage() const override;
 
 };
diff --git a/searchcore/src/vespa/searchcore/proton/test/bucketstatecalculator.h b/searchcore/src/vespa/searchcore/proton/test/bucketstatecalculator.h
index 4dc91883bba..f321b70f028 100644
--- a/searchcore/src/vespa/searchcore/proton/test/bucketstatecalculator.h
+++ b/searchcore/src/vespa/searchcore/proton/test/bucketstatecalculator.h
@@ -83,6 +83,7 @@ public:
     bool nodeRetired() const override { return _nodeRetired; }
     bool nodeInitializing() const override { return false; }
     bool nodeMaintenance() const noexcept override { return _nodeMaintenance; }
+    bool node_retired_or_maintenance() const noexcept override { return _nodeRetired || _nodeMaintenance; }
 };
 
 }