MB-66628: SetParam must use CAS=0 [3/8]

ns_server never implemented the support for setting the control token
which means that it has always provided CAS == 0. Remove support for
the control token as the list of commands supporting it isn't very
consistent and a new task should be scheduled to do a full scrub over
all commands if we want to implement this.

Change-Id: I1d2e37620f8d26c3f3685d8a579374aefd6c4ae5
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/227526
Reviewed-by: Vesko Karaganev <vesko.karaganev@couchbase.com>
Tested-by: Build Bot <build@couchbase.com>

Author: trondn

daemon/mcbp_executors.cc

@@ -53,6 +53,7 @@
 #include "protocol/mcbp/set_active_encryption_keys_context.h"
 #include "protocol/mcbp/set_chronicle_auth_token_command_context.h"
 #include "protocol/mcbp/set_cluster_config_command_context.h"
+#include "protocol/mcbp/set_param_command_context.h"
 #include "protocol/mcbp/settings_reload_command_context.h"
 #include "protocol/mcbp/single_state_steppable_context.h"
 #include "protocol/mcbp/start_fusion_uploader_command_context.h"
@@ -576,7 +577,7 @@ static void update_user_permissions_executor(Cookie& cookie) {
 }
 
 static void set_param_executor(Cookie& cookie) {
-    cookie.obtainContext<SetParameterCommandContext>(cookie).drive();
+    cookie.obtainContext<SetParamCommandContext>(cookie).drive();
 }
 
 static void get_vbucket_executor(Cookie& cookie) {

daemon/mcbp_validators.cc

@@ -2353,7 +2353,7 @@ static Status set_param_validator(Cookie& cookie) {
                                                sizeof(SetParamPayload),
                                                ExpectedKeyLen::NonZero,
                                                ExpectedValueLen::NonZero,
-                                               ExpectedCas::Any,
+                                               ExpectedCas::NotSet,
                                                GeneratesDocKey::No,
                                                PROTOCOL_BINARY_RAW_BYTES);
 

daemon/protocol/mcbp/CMakeLists.txt

@@ -106,6 +106,8 @@ add_library(memcached_daemon_mcbp OBJECT
         set_chronicle_auth_token_command_context.h
         set_cluster_config_command_context.cc
         set_cluster_config_command_context.h
+        set_param_command_context.cc
+        set_param_command_context.h
         settings_reload_command_context.cc
         settings_reload_command_context.h
         single_state_steppable_context.cc

daemon/protocol/mcbp/session_validated_command_context.cc

@@ -40,41 +40,6 @@ cb::engine_errc SessionValidatedCommandContext::step() {
     return ret;
 }
 
-static EngineParamCategory getParamCategory(Cookie& cookie) {
-    const auto& req = cookie.getRequest();
-    using cb::mcbp::request::SetParamPayload;
-    const auto& payload = req.getCommandSpecifics<SetParamPayload>();
-    switch (payload.getParamType()) {
-    case SetParamPayload::Type::Flush:
-        return EngineParamCategory::Flush;
-    case SetParamPayload::Type::Checkpoint:
-        return EngineParamCategory::Checkpoint;
-    case SetParamPayload::Type::Dcp:
-        return EngineParamCategory::Dcp;
-    case SetParamPayload::Type::Vbucket:
-        return EngineParamCategory::Vbucket;
-    case SetParamPayload::Type::Replication:
-        Expects(false && "mcbp_validator should reject this group");
-    }
-    throw std::invalid_argument("getParamCategory(): Invalid param provided: " +
-                                std::to_string(int(payload.getParamType())));
-}
-
-SetParameterCommandContext::SetParameterCommandContext(Cookie& cookie)
-    : SessionValidatedCommandContext(cookie),
-      category(getParamCategory(cookie)) {
-}
-
-cb::engine_errc SetParameterCommandContext::sessionLockedStep() {
-    // We can't cache the key and value as a ewb would relocate them
-    const auto& req = cookie.getRequest();
-    return bucket_set_parameter(cookie,
-                                category,
-                                req.getKeyString(),
-                                req.getValueString(),
-                                req.getVBucket());
-}
-
 cb::engine_errc CompactDatabaseCommandContext::sessionLockedStep() {
     return bucket_compact_database(cookie);
 }

daemon/protocol/mcbp/session_validated_command_context.h

@@ -43,18 +43,6 @@ class SessionValidatedCommandContext : public SteppableCommandContext {
     const bool valid;
 };
 
-/// Class to implement the SetParam command
-class SetParameterCommandContext : public SessionValidatedCommandContext {
-public:
-    explicit SetParameterCommandContext(Cookie& cookie);
-
-protected:
-    cb::engine_errc sessionLockedStep() override;
-
-private:
-    const EngineParamCategory category;
-};
-
 /// Class to implement the CompactDB command
 class CompactDatabaseCommandContext : public SessionValidatedCommandContext {
 public:

daemon/protocol/mcbp/set_param_command_context.cc

@@ -0,0 +1,62 @@
+/*
+ *     Copyright 2025-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#include "set_param_command_context.h"
+#include "engine_wrapper.h"
+#include <daemon/buckets.h>
+#include <daemon/concurrency_semaphores.h>
+#include <daemon/connection.h>
+#include <logger/logger.h>
+#include <memcached/engine.h>
+
+EngineParamCategory SetParamCommandContext::getParamCategory(Cookie& cookie) {
+    const auto& req = cookie.getRequest();
+    using cb::mcbp::request::SetParamPayload;
+    const auto& payload = req.getCommandSpecifics<SetParamPayload>();
+    switch (payload.getParamType()) {
+    case SetParamPayload::Type::Flush:
+        return EngineParamCategory::Flush;
+    case SetParamPayload::Type::Checkpoint:
+        return EngineParamCategory::Checkpoint;
+    case SetParamPayload::Type::Dcp:
+        return EngineParamCategory::Dcp;
+    case SetParamPayload::Type::Vbucket:
+        return EngineParamCategory::Vbucket;
+    case SetParamPayload::Type::Replication:
+        Expects(false && "mcbp_validator should reject this group");
+    }
+    throw std::invalid_argument(
+            "SetParamCommandContext::getParamCategory(): Invalid param "
+            "provided: " +
+            std::to_string(int(payload.getParamType())));
+}
+
+SetParamCommandContext::SetParamCommandContext(Cookie& cookie)
+    : SteppableCommandContext(cookie),
+      category(getParamCategory(cookie)),
+      key(cookie.getRequest().getKeyString()),
+      value(cookie.getRequest().getValueString()),
+      vbid(cookie.getRequest().getVBucket()) {
+}
+
+cb::engine_errc SetParamCommandContext::step() {
+    cb::engine_errc ret = cb::engine_errc::success;
+    try {
+        ret = bucket_set_parameter(cookie, category, key, value, vbid);
+    } catch (const std::exception& e) {
+        LOG_WARNING_CTX("SetParamCommandContext: ",
+                        {"conn_id", cookie.getConnectionId()},
+                        {"error", e.what()});
+    }
+    if (ret == cb::engine_errc::success) {
+        cookie.sendResponse(ret);
+    }
+    return ret;
+}

daemon/protocol/mcbp/set_param_command_context.h

@@ -0,0 +1,28 @@
+/*
+ *     Copyright 2025-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#pragma once
+
+#include "steppable_command_context.h"
+
+/// Command context for executing SetParam requests
+class SetParamCommandContext : public SteppableCommandContext {
+public:
+    explicit SetParamCommandContext(Cookie& cookie);
+
+protected:
+    static EngineParamCategory getParamCategory(Cookie& cookie);
+
+    cb::engine_errc step() override;
+    const EngineParamCategory category;
+    const std::string key;
+    const std::string value;
+    const Vbid vbid;
+};

tests/mcbp/mcbp_test_2.cc

@@ -405,9 +405,9 @@ TEST_P(SetParamValidatorTest, InvalidDatatype) {
     EXPECT_EQ(cb::mcbp::Status::Einval, validate());
 }
 
-TEST_P(SetParamValidatorTest, Cas) {
+TEST_P(SetParamValidatorTest, InvalidCas) {
     req.setCas(0xff);
-    EXPECT_EQ(cb::mcbp::Status::Success, validate());
+    EXPECT_EQ(cb::mcbp::Status::Einval, validate());
 }
 
 TEST_P(SetParamValidatorTest, InvalidKey) {