Make implicit bucket priority DB clearing on scheduling configurable

2 files changed, 53 insertions, 8 deletions

diff --git a/storage/src/tests/distributor/distributor_stripe_test.cpp b/storage/src/tests/distributor/distributor_stripe_test.cpp
index 556f5e20fb2..902dd6454f1 100644
--- a/storage/src/tests/distributor/distributor_stripe_test.cpp
+++ b/storage/src/tests/distributor/distributor_stripe_test.cpp
@@ -179,6 +179,16 @@ struct DistributorStripeTest : Test, DistributorStripeTestUtil {
         configure_stripe(builder);
     }
 
+    void configure_implicitly_clear_priority_on_schedule(bool implicitly_clear) {
+        ConfigBuilder builder;
+        builder.implicitlyClearBucketPriorityOnSchedule = implicitly_clear;
+        configure_stripe(builder);
+    }
+
+    bool scheduler_has_implicitly_clear_priority_on_schedule_set() const noexcept {
+        return _stripe->_scheduler->implicitly_clear_priority_on_schedule();
+    }
+
     void configureMaxClusterClockSkew(int seconds);
     void configure_mutation_sequencing(bool enabled);
     void configure_merge_busy_inhibit_duration(int seconds);
@@ -888,6 +898,17 @@ TEST_F(DistributorStripeTest, max_activation_inhibited_out_of_sync_groups_config
     EXPECT_EQ(getConfig().max_activation_inhibited_out_of_sync_groups(), 0);
 }
 
+TEST_F(DistributorStripeTest, implicitly_clear_priority_on_schedule_config_is_propagated_to_scheduler)
+{
+    setup_stripe(Redundancy(1), NodeCount(1), "distributor:1 storage:1");
+
+    configure_implicitly_clear_priority_on_schedule(true);
+    EXPECT_TRUE(scheduler_has_implicitly_clear_priority_on_schedule_set());
+
+    configure_implicitly_clear_priority_on_schedule(false);
+    EXPECT_FALSE(scheduler_has_implicitly_clear_priority_on_schedule_set());
+}
+
 TEST_F(DistributorStripeTest, wanted_split_bit_count_is_lower_bounded)
 {
     setup_stripe(Redundancy(1), NodeCount(1), "distributor:1 storage:1");
diff --git a/storage/src/tests/distributor/maintenanceschedulertest.cpp b/storage/src/tests/distributor/maintenanceschedulertest.cpp
index 8f13e10fedc..1d85de28aab 100644
--- a/storage/src/tests/distributor/maintenanceschedulertest.cpp
+++ b/storage/src/tests/distributor/maintenanceschedulertest.cpp
@@ -17,7 +17,7 @@ using document::BucketId;
 using Priority = MaintenancePriority;
 using WaitTimeMs = MaintenanceScheduler::WaitTimeMs;
 
-struct MaintenanceSchedulerTest : Test {
+struct MaintenanceSchedulerTest : TestWithParam<bool> {
     SimpleBucketPriorityDatabase      _priority_db;
     MockMaintenanceOperationGenerator _operation_generator;
     MockOperationStarter              _operation_starter;
@@ -31,22 +31,29 @@ struct MaintenanceSchedulerTest : Test {
           _pending_window_checker(),
           _scheduler(_operation_generator, _priority_db, _pending_window_checker, _operation_starter)
     {}
+
+    void SetUp() override {
+        _scheduler.set_implicitly_clear_priority_on_schedule(GetParam());
+    }
 };
 
-TEST_F(MaintenanceSchedulerTest, priority_cleared_after_scheduled) {
+TEST_P(MaintenanceSchedulerTest, priority_cleared_after_scheduled) {
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::HIGHEST));
     _scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE);
     EXPECT_EQ("", _priority_db.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, operation_is_scheduled) {
+TEST_P(MaintenanceSchedulerTest, operation_is_scheduled) {
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::MEDIUM));
     _scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE);
     EXPECT_EQ("Bucket(BucketSpace(0x0000000000000001), BucketId(0x4000000000000001)), pri 100\n",
               _operation_starter.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, operation_is_not_scheduled_if_pending_ops_not_accepted) {
+TEST_P(MaintenanceSchedulerTest, operation_is_not_scheduled_if_pending_ops_not_accepted) {
+    if (!GetParam()) {
+        return; // Only works when implicit clearing is enabled
+    }
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::MEDIUM));
     _pending_window_checker.allow_operations(false);
     _scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE);
@@ -56,13 +63,13 @@ TEST_F(MaintenanceSchedulerTest, operation_is_not_scheduled_if_pending_ops_not_a
               _priority_db.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, no_operations_to_schedule) {
+TEST_P(MaintenanceSchedulerTest, no_operations_to_schedule) {
     WaitTimeMs waitMs(_scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE));
     EXPECT_EQ(WaitTimeMs(1), waitMs);
     EXPECT_EQ("", _operation_starter.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, suppress_low_priorities_in_emergency_mode) {
+TEST_P(MaintenanceSchedulerTest, suppress_low_priorities_in_emergency_mode) {
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::VERY_HIGH));
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 2)), Priority::HIGHEST));
     EXPECT_EQ(WaitTimeMs(0), _scheduler.tick(MaintenanceScheduler::RECOVERY_SCHEDULING_MODE));
@@ -73,7 +80,22 @@ TEST_F(MaintenanceSchedulerTest, suppress_low_priorities_in_emergency_mode) {
               _priority_db.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, priority_cleared_if_operation_not_started_inside_pending_window) {
+TEST_P(MaintenanceSchedulerTest, priority_not_cleared_if_operation_not_started) {
+    if (GetParam()) {
+        return; // Only works when implicit clearing is NOT enabled
+    }
+    _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::HIGH));
+    _operation_starter.setShouldStartOperations(false);
+    WaitTimeMs waitMs(_scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE));
+    EXPECT_EQ(WaitTimeMs(1), waitMs);
+    EXPECT_EQ("PrioritizedBucket(Bucket(BucketSpace(0x0000000000000001), BucketId(0x4000000000000001)), pri HIGH)\n",
+              _priority_db.toString());
+}
+
+TEST_P(MaintenanceSchedulerTest, priority_cleared_if_operation_not_started_inside_pending_window) {
+    if (!GetParam()) {
+        return; // Only works when implicit clearing is enabled
+    }
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::HIGH));
     _operation_starter.setShouldStartOperations(false);
     WaitTimeMs waitMs(_scheduler.tick(MaintenanceScheduler::NORMAL_SCHEDULING_MODE));
@@ -81,7 +103,7 @@ TEST_F(MaintenanceSchedulerTest, priority_cleared_if_operation_not_started_insid
     EXPECT_EQ("", _priority_db.toString());
 }
 
-TEST_F(MaintenanceSchedulerTest, priority_not_cleared_if_operation_not_started_outside_pending_window) {
+TEST_P(MaintenanceSchedulerTest, priority_not_cleared_if_operation_not_started_outside_pending_window) {
     _priority_db.setPriority(PrioritizedBucket(makeDocumentBucket(BucketId(16, 1)), Priority::HIGH));
     _operation_starter.setShouldStartOperations(false);
     _pending_window_checker.allow_operations(false);
@@ -91,4 +113,6 @@ TEST_F(MaintenanceSchedulerTest, priority_not_cleared_if_operation_not_started_o
               _priority_db.toString());
 }
 
+VESPA_GTEST_INSTANTIATE_TEST_SUITE_P(ImplicitClearOfDbPri, MaintenanceSchedulerTest, ::testing::Values(false, true));
+
 }