MB-56581: Allow tuning of default reserved and hard limit

Add the ability to tune the reserved and hard limit being used
without having to replace the static configuration file.

Change-Id: I2e4fb6a082e790d722f327951c49d15050a1f1c7
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/190037
Tested-by: Build Bot <[email protected]>
Reviewed-by: Michael Blow <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>

Author: trondn

daemon/mcbp_executors.cc

@@ -520,9 +520,20 @@ static void set_node_throttle_properties_executor(Cookie& cookie) {
         return;
     }
 
-    auto json = nlohmann::json::parse(cookie.getHeader().getValueString());
+    const cb::throttle::SetNodeThrottleLimitPayload limits =
+            nlohmann::json::parse(cookie.getHeader().getValueString());
     auto& instance = cb::serverless::Config::instance();
-    instance.nodeCapacity = json.value("capacity", 0ULL);
+    if (limits.capacity) {
+        instance.nodeCapacity = limits.capacity.value();
+    }
+    if (limits.default_throttle_reserved_units) {
+        instance.defaultThrottleReservedUnits =
+                limits.default_throttle_reserved_units.value();
+    }
+    if (limits.default_throttle_hard_limit) {
+        instance.defaultThrottleHardLimit =
+                limits.default_throttle_hard_limit.value();
+    }
     cookie.sendResponse(cb::mcbp::Status::Success);
 }
 

daemon/mcbp_validators.cc

@@ -1698,16 +1698,13 @@ static Status set_node_throttle_properties_validator(Cookie& cookie) {
     }
 
     try {
-        auto json = nlohmann::json::parse(payload);
-        if (!json.contains("capacity") || !json["capacity"].is_number() ||
-            json.value("capacity", -1L) < 1) {
-            cookie.setErrorContext(
-                    R"("capacity" must specified and greater than 0)");
-            return Status::Einval;
-        }
+        const cb::throttle::SetNodeThrottleLimitPayload limits =
+                nlohmann::json::parse(cookie.getHeader().getValueString());
+        (void)limits;
     } catch (const std::exception& exception) {
-        cookie.setErrorContext(fmt::format("Failed to parse attached JSON: {}",
-                                           exception.what()));
+        cookie.setErrorContext(
+                fmt::format("Invalid payload for SetNodeThrottleProperties: {}",
+                            exception.what()));
         return Status::Einval;
     }
     return Status::Success;

docs/Throttling.md

@@ -56,9 +56,19 @@ following syntax:
 
     {
       "capacity" : 25000, 
+      "default_throttle_hard_limit" : 5000,
+      "default_throttle_reserved_units" : 2500
     }
 
-"capacity" is the number of units per second
+"capacity" is the number of units per second.
+
+"default_throttle_hard_limit" is the hard limit of number of units per second.
+
+"default_throttle_reserved_units" is the number of units per second reserved
+for the bucket.
+
+Note that default_throttle_hard_limit and default_throttle_reserved_units will
+only affect buckets created after their value is set.
 
 The "default" settings would be stored in
 `/etc/couchbase/kv/serverless/config.json`

utilities/throttle_utilities.cc

@@ -41,8 +41,8 @@ std::size_t get_limit(const nlohmann::json& json,
             return std::numeric_limits<std::size_t>::max();
         }
         throw std::runtime_error(
-                fmt::format("from_json(SetThrottleLimitPayload): {} must be "
-                            "set to \"{}\" if passed as a string",
+                fmt::format("from_json(Set[Node]ThrottleLimitPayload): {} must "
+                            "be set to \"{}\" if passed as a string",
                             key,
                             unlimited));
     }
@@ -59,4 +59,51 @@ void from_json(const nlohmann::json& json, SetThrottleLimitPayload& object) {
     object.reserved = get_limit(json, "reserved");
     object.hard_limit = get_limit(json, "hard_limit");
 }
+
+void to_json(nlohmann::json& json, const SetNodeThrottleLimitPayload& object) {
+    if (object.capacity) {
+        json["capacity"] = limit_to_json(object.capacity.value());
+    }
+    if (object.default_throttle_reserved_units) {
+        json["default_throttle_reserved_units"] =
+                limit_to_json(object.default_throttle_reserved_units.value());
+    }
+    if (object.default_throttle_hard_limit) {
+        json["default_throttle_hard_limit"] =
+                limit_to_json(object.default_throttle_hard_limit.value());
+    }
+}
+
+void from_json(const nlohmann::json& json,
+               SetNodeThrottleLimitPayload& object) {
+    if (json.contains("capacity")) {
+        object.capacity = get_limit(json, "capacity");
+    }
+
+    if (json.contains("default_throttle_reserved_units")) {
+        object.default_throttle_reserved_units =
+                get_limit(json, "default_throttle_reserved_units");
+    }
+    if (json.contains("default_throttle_hard_limit")) {
+        object.default_throttle_hard_limit =
+                get_limit(json, "default_throttle_hard_limit");
+    }
+
+    if (object.default_throttle_hard_limit ||
+        object.default_throttle_reserved_units) {
+        if (!(object.default_throttle_hard_limit &&
+              object.default_throttle_reserved_units)) {
+            // both must be present
+            throw std::invalid_argument(
+                    "both hard and reserved must be provided");
+        }
+
+        // hard must be >= reserved
+        if (object.default_throttle_hard_limit <
+            object.default_throttle_reserved_units) {
+            throw std::invalid_argument("hard must be >= reserved");
+        }
+    }
+}
+
 } // namespace cb::throttle

utilities/throttle_utilities.h

@@ -12,6 +12,7 @@
 
 #include <nlohmann/json_fwd.hpp>
 #include <limits>
+#include <optional>
 
 namespace cb::throttle {
 
@@ -41,4 +42,17 @@ void to_json(nlohmann::json& json, const SetThrottleLimitPayload& object);
 /// Initialize the SetThrottleLimitPayload object from JSON
 void from_json(const nlohmann::json& json, SetThrottleLimitPayload& object);
 
+/// The payload in the SetNodeThrottleLimit command
+struct SetNodeThrottleLimitPayload {
+    std::optional<std::size_t> capacity;
+    std::optional<std::size_t> default_throttle_reserved_units;
+    std::optional<std::size_t> default_throttle_hard_limit;
+};
+
+/// Convert the SetNodeThrottleLimitPayload to a JSON document
+void to_json(nlohmann::json& json, const SetNodeThrottleLimitPayload& object);
+
+/// Initialize the SetNodeThrottleLimitPayload object from JSON
+void from_json(const nlohmann::json& json, SetNodeThrottleLimitPayload& object);
+
 } // namespace cb::throttle

utilities/throttle_utilities_test.cc

@@ -14,30 +14,94 @@
 
 using namespace cb::throttle;
 
-TEST(ThrottleLimitPayload, AllDefault) {
+TEST(SetThrottleLimitPayload, AllDefault) {
     SetThrottleLimitPayload limits = nlohmann::json::parse("{}");
     EXPECT_EQ(std::numeric_limits<std::size_t>::max(), limits.reserved);
     EXPECT_EQ(std::numeric_limits<std::size_t>::max(), limits.hard_limit);
 }
 
-TEST(ThrottleLimitPayload, NumericValues) {
+TEST(SetThrottleLimitPayload, NumericValues) {
     SetThrottleLimitPayload limits =
             nlohmann::json::parse(R"({"reserved": 1, "hard_limit": 2})");
     EXPECT_EQ(1, limits.reserved);
     EXPECT_EQ(2, limits.hard_limit);
 }
 
-TEST(ThrottleLimitPayload, StringValues) {
+TEST(SetThrottleLimitPayload, StringValues) {
     SetThrottleLimitPayload limits = nlohmann::json::parse(
             R"({"reserved": 1, "hard_limit": "unlimited"})");
     EXPECT_EQ(1, limits.reserved);
     EXPECT_EQ(std::numeric_limits<std::size_t>::max(), limits.hard_limit);
 }
 
-TEST(ThrottleLimitPayload, ToJson) {
+TEST(SetThrottleLimitPayload, ToJson) {
     nlohmann::json json = SetThrottleLimitPayload();
     EXPECT_EQ(R"({"hard_limit":"unlimited","reserved":"unlimited"})",
               json.dump());
     json = SetThrottleLimitPayload(1, 2);
     EXPECT_EQ(R"({"hard_limit":2,"reserved":1})", json.dump());
 }
+
+TEST(SetNodeThrottleLimitPayload, AllDefault) {
+    SetNodeThrottleLimitPayload limits = nlohmann::json::parse("{}");
+    EXPECT_FALSE(limits.capacity);
+    EXPECT_FALSE(limits.default_throttle_reserved_units);
+    EXPECT_FALSE(limits.default_throttle_hard_limit);
+}
+
+TEST(SetNodeThrottleLimitPayload, Capacity) {
+    SetNodeThrottleLimitPayload limits =
+            nlohmann::json::parse(R"({"capacity":1})");
+    EXPECT_TRUE(limits.capacity);
+    EXPECT_EQ(1, limits.capacity.value());
+    EXPECT_FALSE(limits.default_throttle_reserved_units);
+    EXPECT_FALSE(limits.default_throttle_hard_limit);
+
+    limits = nlohmann::json::parse(R"({"capacity":0})");
+    EXPECT_TRUE(limits.capacity);
+    EXPECT_EQ(0, limits.capacity.value());
+
+    limits = nlohmann::json::parse(R"({"capacity":"unlimited"})");
+    EXPECT_TRUE(limits.capacity);
+    EXPECT_EQ(std::numeric_limits<std::size_t>::max(), limits.capacity.value());
+}
+
+TEST(SetNodeThrottleLimitPayload, DefaultThrottle) {
+    SetNodeThrottleLimitPayload limits =
+            nlohmann::json{{"default_throttle_reserved_units", 10},
+                           {"default_throttle_hard_limit", 25}};
+    EXPECT_FALSE(limits.capacity);
+    EXPECT_TRUE(limits.default_throttle_reserved_units);
+    EXPECT_TRUE(limits.default_throttle_hard_limit);
+    EXPECT_EQ(10, limits.default_throttle_reserved_units.value());
+    EXPECT_EQ(25, limits.default_throttle_hard_limit.value());
+
+    // They may be equal
+    limits = nlohmann::json{{"default_throttle_reserved_units", 40},
+                            {"default_throttle_hard_limit", 40}};
+    EXPECT_FALSE(limits.capacity);
+    EXPECT_TRUE(limits.default_throttle_reserved_units);
+    EXPECT_TRUE(limits.default_throttle_hard_limit);
+    EXPECT_EQ(40, limits.default_throttle_reserved_units.value());
+    EXPECT_EQ(40, limits.default_throttle_hard_limit.value());
+
+    // They may be string
+    limits = nlohmann::json{{"default_throttle_reserved_units", "unlimited"},
+                            {"default_throttle_hard_limit", "unlimited"}};
+    EXPECT_FALSE(limits.capacity);
+    EXPECT_TRUE(limits.default_throttle_reserved_units);
+    EXPECT_TRUE(limits.default_throttle_hard_limit);
+    EXPECT_EQ(std::numeric_limits<std::size_t>::max(),
+              limits.default_throttle_reserved_units.value());
+    EXPECT_EQ(std::numeric_limits<std::size_t>::max(),
+              limits.default_throttle_hard_limit.value());
+
+    // but reserved cannot exceed hard
+    try {
+        limits =
+                nlohmann::json{{"default_throttle_reserved_units", "unlimited"},
+                               {"default_throttle_hard_limit", 100}};
+        FAIL() << "reserved must be less or equal to hard limit";
+    } catch (const std::exception&) {
+    }
+}