couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/frame_info_id_fmt.hxx

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "frame_info_id.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::request_frame_info_id> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::request_frame_info_id opcode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::core::protocol::request_frame_info_id::barrier:
+                name = "barrier";
+                break;
+            case couchbase::core::protocol::request_frame_info_id::durability_requirement:
+                name = "durability_requirement";
+                break;
+            case couchbase::core::protocol::request_frame_info_id::dcp_stream_id:
+                name = "dcp_stream_id";
+                break;
+            case couchbase::core::protocol::request_frame_info_id::open_tracing_context:
+                name = "open_tracing_context";
+                break;
+            case couchbase::core::protocol::request_frame_info_id::impersonate_user:
+                name = "impersonate_user";
+                break;
+            case couchbase::core::protocol::request_frame_info_id::preserve_ttl:
+                name = "preserve_ttl";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::response_frame_info_id> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::response_frame_info_id opcode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::core::protocol::response_frame_info_id::server_duration:
+                name = "server_duration";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/frame_info_utils.cxx

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "frame_info_utils.hxx"
+
+#include "core/utils/byteswap.hxx"
+#include "frame_info_id.hxx"
+
+#include <cstddef>
+#include <cstring>
+
+namespace couchbase::core::protocol
+{
+
+void
+add_durability_frame_info(std::vector<std::byte>& framing_extras, durability_level level, std::optional<std::uint16_t> timeout)
+{
+    const auto frame_id = static_cast<std::byte>(protocol::request_frame_info_id::durability_requirement);
+    const auto extras_old_size = framing_extras.size();
+    if (timeout) {
+        const std::byte frame_size{ 3 };
+        framing_extras.resize(extras_old_size + 1 + static_cast<std::size_t>(frame_size));
+        framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+        framing_extras[extras_old_size + 1] = static_cast<std::byte>(level);
+        std::uint16_t val = utils::byte_swap(*timeout);
+        memcpy(framing_extras.data() + extras_old_size + 2, &val, sizeof(val));
+    } else {
+        const std::byte frame_size{ 3 };
+        framing_extras.resize(extras_old_size + 1 + static_cast<std::size_t>(frame_size));
+        framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+        framing_extras[extras_old_size + 1] = static_cast<std::byte>(level);
+    }
+}
+
+void
+add_preserve_expiry_frame_info(std::vector<std::byte>& framing_extras)
+{
+    const auto frame_id = static_cast<std::byte>(protocol::request_frame_info_id::preserve_ttl);
+    const std::byte frame_size{ 0 };
+    const auto extras_old_size = framing_extras.size();
+
+    framing_extras.resize(extras_old_size + 1);
+    framing_extras[extras_old_size + 0] = (frame_id << 4U) | frame_size;
+}
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/frame_info_utils.hxx

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/durability_level.hxx>
+
+#include <cinttypes>
+#include <optional>
+#include <vector>
+
+namespace couchbase::core::protocol
+{
+
+/**
+ * Encodes durability level with optional timeout and appends result to @c framing_extras.
+ *
+ * @param framing_extras output storage for extras
+ * @param level durability level
+ * @param timeout durability timeout
+ *
+ * @since 1.1.0
+ * @internal
+ */
+void
+add_durability_frame_info(std::vector<std::byte>& framing_extras, durability_level level, std::optional<std::uint16_t> timeout);
+
+/**
+ * Appends "preserve expiry" frame to @c framing_extras.
+ *
+ * @param framing_extras output storage for extras
+ *
+ * @since 1.1.0
+ * @internal
+ */
+void
+add_preserve_expiry_frame_info(std::vector<std::byte>& framing_extras);
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/hello_feature.hxx

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace couchbase::core::protocol
+{
+enum class hello_feature : std::uint16_t {
+    /**
+     * The client wants to TLS and send STARTTLS
+     */
+    tls = 0x02,
+
+    /**
+     * The client requests the server to set TCP NODELAY on the socket used by this connection.
+     */
+    tcp_nodelay = 0x03,
+
+    /**
+     * The client requests the server to add the sequence number for a mutation to the response packet used in mutations.
+     */
+    mutation_seqno = 0x04,
+
+    /**
+     * The client requests the server to set TCP DELAY on the socket used by this connection
+     */
+    tcp_delay = 0x05,
+
+    /**
+     * The client requests the server to add XATTRs to the stream for commands where it makes sense (GetWithMeta, SetWithMeta, DcpMutation
+     * etc)
+     */
+    xattr = 0x06,
+
+    /**
+     * The client requests the server to send extended error codes instead of disconnecting the client when new errors occur (note that some
+     * errors may be remapped to more generic error codes instead of disconnecting)
+     */
+    xerror = 0x07,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it should
+     * be able to run select bucket or not (select bucket was a privileged command pre-spock. In spock all users may run select bucket, but
+     * only to a bucket they have access to).
+     */
+    select_bucket = 0x08,
+
+    /**
+     * The client wants to enable support for Snappy compression. A client with support for Snappy compression must update the datatype
+     * filed in the requests with the bit representing SNAPPY when sending snappy compressed data to the server. It must be able to receive
+     * data from the server compressed with SNAPPY identified by the bit being set in the datatype field
+     */
+    snappy = 0x0a,
+
+    /**
+     * The client wants to enable support for JSON. The client must set this bit when storing JSON documents on the server. The server will
+     * set the appropriate bit in the datatype field when returning such documents to the client
+     */
+    json = 0x0b,
+
+    /**
+     * The client allows for full duplex on the socket. This means that the server may send requests back to the client. These messages is
+     * identified by the magic values of 0x82 (request) and 0x83 (response). See the document Duplex for more information.
+     *
+     * https://github.com/couchbase/kv_engine/blob/master/docs/Duplex.md
+     */
+    duplex = 0x0c,
+
+    /**
+     * The client wants the server to notify the client with new cluster maps whenever ns_server push them to memcached. (note that this
+     * notification is subject to deduplication of the vbucket map received as part of not my vbucket)
+     */
+    clustermap_change_notification = 0x0d,
+
+    /**
+     * The client allows the server to reorder the execution of commands. See the document UnorderedExecution for more information
+     *
+     * https://github.com/couchbase/kv_engine/blob/master/docs/UnorderedExecution.md
+     */
+    unordered_execution = 0x0e,
+
+    /**
+     * The client wants the server to include tracing information in the response packet
+     */
+    tracing = 0x0f,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it may
+     * send the alternative request packet (magic 0x08) containing FrameInfo segments.
+     */
+    alt_request_support = 0x10,
+
+    /**
+     * This is purely informational (it does not enable/disable anything on the server). It may be used from the client to know if it may
+     * use synchronous replication tags in the mutation requests.
+     */
+    sync_replication = 0x11,
+
+    /**
+     * The client wants to enable support for Collections
+     */
+    collections = 0x12,
+
+    /**
+     * This is purely informational (it does not enable / disable anything on the server). It may be used from the client to figure out if
+     * the server supports OpenTracing or not.)
+     */
+    open_tracing = 0x13,
+
+    /**
+     * This is purely informational (it does not enable / disable anything on the server). It may be used from the client to know if it may
+     * use PreserveTtl in the operations who carries the TTL for a document
+     */
+    preserve_ttl = 0x14,
+
+    /**
+     * This is purely information (it does not enable / disable anything on the server). It may be used from the client to determine if the
+     * server supports VATTRs in a generic way (can request $ and will either succeed or fail with SubdocXattrUnknownVattr). Requires XATTR.
+     */
+    vattr = 0x15,
+
+    /**
+     * This is purely information (it does not enable / disable anything on the server). It may be used from the client to determine if the
+     * server supports Point in Time Recovery
+     */
+    point_in_time_recovery = 0x16,
+
+    /**
+     * Does the server support the subdoc mutation flag create_as_deleted
+     */
+    subdoc_create_as_deleted = 0x17,
+
+    /**
+     * Does the server support using the virtual $document attributes in macro expansion ("${document.CAS}" etc)
+     */
+    subdoc_document_macro_support = 0x18,
+};
+
+constexpr bool
+is_valid_hello_feature(std::uint16_t code)
+{
+    switch (hello_feature(code)) {
+        case hello_feature::tls:
+        case hello_feature::tcp_nodelay:
+        case hello_feature::mutation_seqno:
+        case hello_feature::xattr:
+        case hello_feature::xerror:
+        case hello_feature::select_bucket:
+        case hello_feature::snappy:
+        case hello_feature::json:
+        case hello_feature::duplex:
+        case hello_feature::clustermap_change_notification:
+        case hello_feature::unordered_execution:
+        case hello_feature::alt_request_support:
+        case hello_feature::sync_replication:
+        case hello_feature::vattr:
+        case hello_feature::collections:
+        case hello_feature::open_tracing:
+        case hello_feature::preserve_ttl:
+        case hello_feature::point_in_time_recovery:
+        case hello_feature::tcp_delay:
+        case hello_feature::tracing:
+        case hello_feature::subdoc_create_as_deleted:
+        case hello_feature::subdoc_document_macro_support:
+            return true;
+    }
+    return false;
+}
+
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/hello_feature_fmt.hxx

@@ -0,0 +1,106 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "hello_feature.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::hello_feature> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::hello_feature feature, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (feature) {
+            case couchbase::core::protocol::hello_feature::tls:
+                name = "tls";
+                break;
+            case couchbase::core::protocol::hello_feature::tcp_nodelay:
+                name = "tcp_nodelay";
+                break;
+            case couchbase::core::protocol::hello_feature::mutation_seqno:
+                name = "mutation_seqno";
+                break;
+            case couchbase::core::protocol::hello_feature::xattr:
+                name = "xattr";
+                break;
+            case couchbase::core::protocol::hello_feature::xerror:
+                name = "xerror";
+                break;
+            case couchbase::core::protocol::hello_feature::select_bucket:
+                name = "select_bucket";
+                break;
+            case couchbase::core::protocol::hello_feature::snappy:
+                name = "snappy";
+                break;
+            case couchbase::core::protocol::hello_feature::json:
+                name = "json";
+                break;
+            case couchbase::core::protocol::hello_feature::duplex:
+                name = "duplex";
+                break;
+            case couchbase::core::protocol::hello_feature::clustermap_change_notification:
+                name = "clustermap_change_notification";
+                break;
+            case couchbase::core::protocol::hello_feature::unordered_execution:
+                name = "unordered_execution";
+                break;
+            case couchbase::core::protocol::hello_feature::alt_request_support:
+                name = "alt_request_support";
+                break;
+            case couchbase::core::protocol::hello_feature::sync_replication:
+                name = "sync_replication";
+                break;
+            case couchbase::core::protocol::hello_feature::vattr:
+                name = "vattr";
+                break;
+            case couchbase::core::protocol::hello_feature::collections:
+                name = "collections";
+                break;
+            case couchbase::core::protocol::hello_feature::open_tracing:
+                name = "open_tracing";
+                break;
+            case couchbase::core::protocol::hello_feature::preserve_ttl:
+                name = "preserve_ttl";
+                break;
+            case couchbase::core::protocol::hello_feature::point_in_time_recovery:
+                name = "point_in_time_recovery";
+                break;
+            case couchbase::core::protocol::hello_feature::tcp_delay:
+                name = "tcp_delay";
+                break;
+            case couchbase::core::protocol::hello_feature::tracing:
+                name = "tracing";
+                break;
+            case couchbase::core::protocol::hello_feature::subdoc_create_as_deleted:
+                name = "subdoc_create_as_deleted";
+                break;
+            case couchbase::core::protocol::hello_feature::subdoc_document_macro_support:
+                name = "subdoc_document_macro_support";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/magic.hxx

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace couchbase::core::protocol
+{
+enum class magic : std::uint8_t {
+    /// Request packet from client to server
+    client_request = 0x80,
+    /// The alternative request packet containing frame extras
+    alt_client_request = 0x08,
+    /// Response packet from server to client
+    client_response = 0x81,
+    /// The alternative response packet containing frame extras
+    alt_client_response = 0x18,
+    /// Request packet from server to client
+    server_request = 0x82,
+    /// Response packet from client to server
+    server_response = 0x83
+};
+
+constexpr bool
+is_valid_magic(std::uint8_t code)
+{
+    switch (magic(code)) {
+        case magic::client_request:
+        case magic::alt_client_request:
+        case magic::client_response:
+        case magic::alt_client_response:
+        case magic::server_request:
+        case magic::server_response:
+            return true;
+    }
+    return false;
+}
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/magic_fmt.hxx

@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "magic.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::magic> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::magic code, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (code) {
+            case couchbase::core::protocol::magic::client_request:
+                name = "client_request (0x80)";
+                break;
+            case couchbase::core::protocol::magic::alt_client_request:
+                name = "alt_client_request (0x08)";
+                break;
+            case couchbase::core::protocol::magic::client_response:
+                name = "client_response (0x81)";
+                break;
+            case couchbase::core::protocol::magic::alt_client_response:
+                name = "alt_client_response (0x18)";
+                break;
+            case couchbase::core::protocol::magic::server_request:
+                name = "server_request (0x82)";
+                break;
+            case couchbase::core::protocol::magic::server_response:
+                name = "server_response (0x83)";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/server_opcode.hxx

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+namespace couchbase::core::protocol
+{
+enum class server_opcode : std::uint8_t {
+    cluster_map_change_notification = 0x01,
+    invalid = 0xff,
+};
+
+constexpr bool
+is_valid_server_request_opcode(std::uint8_t code)
+{
+    switch (server_opcode(code)) {
+        case server_opcode::cluster_map_change_notification:
+            return true;
+        case server_opcode::invalid:
+            break;
+    }
+    return false;
+}
+
+} // namespace couchbase::core::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/protocol/server_opcode_fmt.hxx

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "server_opcode.hxx"
+
+#include <fmt/core.h>
+
+template<>
+struct fmt::formatter<couchbase::core::protocol::server_opcode> {
+    template<typename ParseContext>
+    constexpr auto parse(ParseContext& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(couchbase::core::protocol::server_opcode opcode, FormatContext& ctx) const
+    {
+        string_view name = "unknown";
+        switch (opcode) {
+            case couchbase::core::protocol::server_opcode::cluster_map_change_notification:
+                name = "cluster_map_change_notification (0x01)";
+                break;
+            case couchbase::core::protocol::server_opcode::invalid:
+                name = "invalid (0xff)";
+                break;
+        }
+        return format_to(ctx.out(), "{}", name);
+    }
+};