couchbase 3.8.2 → 3.9.1

data/ext/couchbase/core/protocol/cmd_get_and_touch.cxx

@@ -38,7 +38,7 @@ get_and_touch_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
     if (extras_size == 4) {
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
     } else {
       offset += extras_size;
@@ -60,7 +60,7 @@ void
 get_and_touch_request_body::fill_extras()
 {
   extras_.resize(sizeof(expiry_));
-  std::uint32_t field = utils::byte_swap(expiry_);
+  std::uint32_t field = utils::host_to_network(expiry_);
   memcpy(extras_.data(), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get_cluster_config.cxx

@@ -18,6 +18,7 @@
 #include "cmd_get_cluster_config.hxx"
 
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/topology/configuration_json.hxx"
 #include "core/utils/json.hxx"
 
@@ -77,14 +78,15 @@ get_cluster_config_response_body::parse(key_value_status_code status,
   if (status == key_value_status_code::success) {
     const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
-    std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset,
-                                  body.size() - static_cast<std::size_t>(offset) };
+    const std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                        body.size() - static_cast<std::size_t>(offset) };
     try {
       config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
       config_text_.emplace(config_text);
     } catch (const tao::pegtl::parse_error& e) {
-      CB_LOG_DEBUG(
-        "unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
+      CB_LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}",
+                   e.message(),
+                   logger::metadata(config_text));
     }
     return true;
   }

data/ext/couchbase/core/protocol/cmd_get_collection_id.cxx

@@ -41,11 +41,11 @@ get_collection_id_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size + key_size;
 
     std::memcpy(&manifest_uid_, body.data() + offset, sizeof(manifest_uid_));
-    manifest_uid_ = utils::byte_swap(manifest_uid_);
+    manifest_uid_ = utils::network_to_host(manifest_uid_);
     offset += 8;
 
     std::memcpy(&collection_uid_, body.data() + offset, sizeof(collection_uid_));
-    collection_uid_ = utils::byte_swap(collection_uid_);
+    collection_uid_ = utils::network_to_host(collection_uid_);
     return true;
   }
   return false;

data/ext/couchbase/core/protocol/cmd_get_error_map.cxx

@@ -56,7 +56,7 @@ get_error_map_response_body::parse(key_value_status_code status,
 void
 get_error_map_request_body::fill_body()
 {
-  std::uint16_t version = utils::byte_swap(version_);
+  std::uint16_t version = utils::host_to_network(version_);
   value_.resize(sizeof(version));
   std::memcpy(value_.data(), &version, sizeof(version));
 }

data/ext/couchbase/core/protocol/cmd_get_meta.cxx

@@ -40,19 +40,19 @@ get_meta_response_body::parse(key_value_status_code status,
     if (extras_size == sizeof(deleted_) + sizeof(flags_) + sizeof(expiry_) +
                          sizeof(sequence_number_) + sizeof(datatype_)) {
       memcpy(&deleted_, body.data() + offset, sizeof(deleted_));
-      deleted_ = utils::byte_swap(deleted_);
+      deleted_ = utils::network_to_host(deleted_);
       offset += 4;
 
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
 
       memcpy(&expiry_, body.data() + offset, sizeof(expiry_));
-      expiry_ = utils::byte_swap(expiry_);
+      expiry_ = utils::network_to_host(expiry_);
       offset += 4;
 
       memcpy(&sequence_number_, body.data() + offset, sizeof(sequence_number_));
-      sequence_number_ = utils::byte_swap(sequence_number_);
+      sequence_number_ = utils::network_to_host(sequence_number_);
       offset += 8;
 
       datatype_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);

data/ext/couchbase/core/protocol/cmd_get_replica.cxx

@@ -45,7 +45,7 @@ get_replica_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
     if (extras_size == 4) {
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
     } else {
       offset += extras_size;

data/ext/couchbase/core/protocol/cmd_hello.cxx

@@ -48,7 +48,7 @@ hello_response_body::parse(key_value_status_code status,
     for (size_t i = 0; i < num_features; i++) {
       std::uint16_t field = 0;
       std::memcpy(&field, value + (i * 2), sizeof(std::uint16_t));
-      field = utils::byte_swap(field);
+      field = utils::network_to_host(field);
       if (is_valid_hello_feature(field)) {
         supported_features_.push_back(static_cast<hello_feature>(field));
       }

data/ext/couchbase/core/protocol/cmd_increment.cxx

@@ -43,19 +43,19 @@ increment_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       offset += 8;
     }
     offset += key_size;
     memcpy(&content_, body.data() + offset, sizeof(content_));
-    content_ = utils::byte_swap(content_);
+    content_ = utils::network_to_host(content_);
     return true;
   }
   return false;
@@ -84,15 +84,15 @@ increment_request_body::fill_extras()
   using offset_type = std::vector<std::byte>::difference_type;
   offset_type offset = 0;
 
-  std::uint64_t num = utils::byte_swap(delta_);
+  std::uint64_t num = utils::host_to_network(delta_);
   memcpy(extras_.data() + offset, &num, sizeof(num));
   offset += static_cast<offset_type>(sizeof(delta_));
 
-  num = utils::byte_swap(initial_value_);
+  num = utils::host_to_network(initial_value_);
   memcpy(extras_.data() + offset, &num, sizeof(num));
   offset += static_cast<offset_type>(sizeof(initial_value_));
 
-  std::uint32_t ttl = utils::byte_swap(expiry_);
+  std::uint32_t ttl = utils::host_to_network(expiry_);
   memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_insert.cxx

@@ -42,12 +42,12 @@ insert_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;
@@ -74,10 +74,10 @@ insert_request_body::fill_extras()
 {
   extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
-  std::uint32_t field = utils::byte_swap(flags_);
+  std::uint32_t field = utils::host_to_network(flags_);
   memcpy(extras_.data(), &field, sizeof(field));
 
-  field = utils::byte_swap(expiry_);
+  field = utils::host_to_network(expiry_);
   memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_lookup_in.cxx

@@ -48,14 +48,14 @@ lookup_in_response_body::parse(key_value_status_code status,
 
       std::uint16_t entry_status = 0;
       memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-      entry_status = utils::byte_swap(entry_status);
+      entry_status = utils::network_to_host(entry_status);
       Expects(is_valid_status(entry_status));
       field.status = static_cast<key_value_status_code>(entry_status);
       offset += static_cast<offset_type>(sizeof(entry_status));
 
       std::uint32_t entry_size = 0;
       memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-      entry_size = utils::byte_swap(entry_size);
+      entry_size = utils::network_to_host(entry_size);
       Expects(entry_size < 20 * 1024 * 1024);
       offset += static_cast<offset_type>(sizeof(entry_size));
 
@@ -101,7 +101,8 @@ lookup_in_request_body::fill_value()
     ++offset;
     value_[offset] = spec.flags_;
     ++offset;
-    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::uint16_t path_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
     std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
     offset += sizeof(path_size);
     std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());

data/ext/couchbase/core/protocol/cmd_lookup_in_replica.cxx

@@ -47,14 +47,14 @@ lookup_in_replica_response_body::parse(key_value_status_code status,
 
       std::uint16_t entry_status = 0;
       memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-      entry_status = utils::byte_swap(entry_status);
+      entry_status = utils::network_to_host(entry_status);
       Expects(is_valid_status(entry_status));
       field.status = static_cast<key_value_status_code>(entry_status);
       offset += static_cast<offset_type>(sizeof(entry_status));
 
       std::uint32_t entry_size = 0;
       memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-      entry_size = utils::byte_swap(entry_size);
+      entry_size = utils::network_to_host(entry_size);
       Expects(entry_size < 20 * 1024 * 1024);
       offset += static_cast<offset_type>(sizeof(entry_size));
 
@@ -100,7 +100,8 @@ lookup_in_replica_request_body::fill_value()
     ++offset;
     value_[offset] = spec.flags_;
     ++offset;
-    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::uint16_t path_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
     std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
     offset += sizeof(path_size);
     std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());

data/ext/couchbase/core/protocol/cmd_mutate_in.cxx

@@ -44,12 +44,12 @@ mutate_in_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       offset += 8;
@@ -66,7 +66,7 @@ mutate_in_response_body::parse(key_value_status_code status,
 
       std::uint16_t entry_status = 0;
       memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-      entry_status = utils::byte_swap(entry_status);
+      entry_status = utils::network_to_host(entry_status);
       Expects(is_valid_status(entry_status));
       field.status = static_cast<key_value_status_code>(entry_status);
       offset += static_cast<offset_type>(sizeof(entry_status));
@@ -74,7 +74,7 @@ mutate_in_response_body::parse(key_value_status_code status,
       if (field.status == key_value_status_code::success) {
         std::uint32_t entry_size = 0;
         memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-        entry_size = utils::byte_swap(entry_size);
+        entry_size = utils::network_to_host(entry_size);
         Expects(entry_size < 20 * 1024 * 1024);
         offset += static_cast<offset_type>(sizeof(entry_size));
 
@@ -117,16 +117,16 @@ mutate_in_request_body::fill_extras()
 {
   if (expiry_ != 0 || user_flags_) {
     extras_.resize(sizeof(expiry_));
-    std::uint32_t field = utils::byte_swap(expiry_);
+    std::uint32_t field = utils::host_to_network(expiry_);
     memcpy(extras_.data(), &field, sizeof(field));
   }
   if (user_flags_) {
     const std::size_t offset = extras_.size();
     extras_.resize(offset + sizeof(std::uint32_t));
-    std::uint32_t field = utils::byte_swap(user_flags_.value());
+    std::uint32_t field = utils::host_to_network(user_flags_.value());
     memcpy(extras_.data() + offset, &field, sizeof(field));
   }
-  if (flags_ != std::byte{ 0U }) {
+  if (flags_ != std::uint8_t{ 0U }) {
     const std::size_t offset = extras_.size();
     extras_.resize(offset + sizeof(flags_));
     extras_[offset] = std::byte{ flags_ };
@@ -150,12 +150,13 @@ mutate_in_request_body::fill_value()
     value_[offset] = spec.flags_;
     ++offset;
 
-    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::uint16_t path_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
     std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
     offset += sizeof(path_size);
 
     std::uint32_t param_size =
-      utils::byte_swap(gsl::narrow_cast<std::uint32_t>(spec.value_.size()));
+      utils::host_to_network(gsl::narrow_cast<std::uint32_t>(spec.value_.size()));
     std::memcpy(value_.data() + offset, &param_size, sizeof(param_size));
     offset += sizeof(param_size);
 

data/ext/couchbase/core/protocol/cmd_mutate_in.hxx

@@ -81,33 +81,33 @@ public:
    * `path_flag_create_parents`. and `upsert` mutation semantics. Not valid with
    * `insert`.
    */
-  static constexpr std::byte doc_flag_mkdoc{ 0b0000'0001U };
+  static constexpr std::uint8_t doc_flag_mkdoc{ 0b0000'0001U };
 
   /**
    * Add the document only if it does not exist. Implies
    * `path_flag_create_parents`. Not valid with `doc_flag_mkdoc`.
    */
-  static constexpr std::byte doc_flag_add{ 0b0000'0010U };
+  static constexpr std::uint8_t doc_flag_add{ 0b0000'0010U };
 
   /**
    * Allow access to XATTRs for deleted documents (instead of returning
    * KEY_ENOENT).
    */
-  static constexpr std::byte doc_flag_access_deleted{ 0b0000'0100U };
+  static constexpr std::uint8_t doc_flag_access_deleted{ 0b0000'0100U };
 
   /**
    * Used with `doc_flag_mkdoc` / `doc_flag_add`; if the document does not exist
    * then create it in the "Deleted" state, instead of the normal "Alive" state.
    * Not valid unless `doc_flag_mkdoc` or `doc_flag_add` specified.
    */
-  static constexpr std::byte doc_flag_create_as_deleted{ 0b0000'1000U };
+  static constexpr std::uint8_t doc_flag_create_as_deleted{ 0b0000'1000U };
 
   /**
    * If the document exists and isn't deleted the operation will fail with .
    * If the input document _is_ deleted the result of the operation will store
    * the document as a "live" document instead of a deleted document.
    */
-  static constexpr std::byte doc_flag_revive_document{ 0b0001'0000U };
+  static constexpr std::uint8_t doc_flag_revive_document{ 0b0001'0000U };
 
 private:
   std::vector<std::byte> key_;
@@ -116,7 +116,7 @@ private:
 
   std::optional<std::uint32_t> user_flags_{};
   std::uint32_t expiry_{ 0 };
-  std::byte flags_{ 0 };
+  std::uint8_t flags_{ 0 };
   std::vector<couchbase::core::impl::subdoc::command> specs_;
   std::vector<std::byte> framing_extras_{};
 
@@ -138,7 +138,7 @@ public:
     if (value) {
       flags_ |= doc_flag_access_deleted;
     } else {
-      flags_ &= ~doc_flag_access_deleted;
+      flags_ &= static_cast<std::uint8_t>(~doc_flag_access_deleted);
     }
   }
 
@@ -147,7 +147,7 @@ public:
     if (value) {
       flags_ |= doc_flag_create_as_deleted;
     } else {
-      flags_ &= ~doc_flag_create_as_deleted;
+      flags_ &= static_cast<std::uint8_t>(~doc_flag_create_as_deleted);
     }
   }
 
@@ -156,13 +156,13 @@ public:
     if (value) {
       flags_ |= doc_flag_revive_document;
     } else {
-      flags_ &= ~doc_flag_revive_document;
+      flags_ &= static_cast<std::uint8_t>(~doc_flag_revive_document);
     }
   }
 
   void store_semantics(couchbase::store_semantics semantics)
   {
-    flags_ &= std::byte{ 0b1111'1100U }; /* reset first two bits */
+    flags_ &= static_cast<std::uint8_t>(0b1111'1100U); /* reset first two bits */
     switch (semantics) {
       case couchbase::store_semantics::replace:
         /* leave bits as zeros */

data/ext/couchbase/core/protocol/cmd_observe_seqno.cxx

@@ -45,32 +45,32 @@ observe_seqno_response_body::parse(key_value_status_code status,
     ++offset;
 
     memcpy(&partition_id_, body.data() + offset, sizeof(partition_id_));
-    partition_id_ = utils::byte_swap(partition_id_);
+    partition_id_ = utils::network_to_host(partition_id_);
     offset += static_cast<offset_type>(sizeof(partition_id_));
 
     memcpy(&partition_uuid_, body.data() + offset, sizeof(partition_uuid_));
-    partition_uuid_ = utils::byte_swap(partition_uuid_);
+    partition_uuid_ = utils::network_to_host(partition_uuid_);
     offset += static_cast<offset_type>(sizeof(partition_uuid_));
 
     memcpy(&last_persisted_sequence_number_,
            body.data() + offset,
            sizeof(last_persisted_sequence_number_));
-    last_persisted_sequence_number_ = utils::byte_swap(last_persisted_sequence_number_);
+    last_persisted_sequence_number_ = utils::network_to_host(last_persisted_sequence_number_);
     offset += static_cast<offset_type>(sizeof(last_persisted_sequence_number_));
 
     memcpy(&current_sequence_number_, body.data() + offset, sizeof(current_sequence_number_));
-    current_sequence_number_ = utils::byte_swap(current_sequence_number_);
+    current_sequence_number_ = utils::network_to_host(current_sequence_number_);
     offset += static_cast<offset_type>(sizeof(current_sequence_number_));
 
     if (failover) {
       std::uint64_t field{};
 
       memcpy(&field, body.data() + offset, sizeof(field));
-      old_partition_uuid_.emplace(utils::byte_swap(field));
+      old_partition_uuid_.emplace(utils::network_to_host(field));
       offset += static_cast<offset_type>(sizeof(field));
 
       memcpy(&field, body.data() + offset, sizeof(field));
-      last_received_sequence_number_.emplace(utils::byte_swap(field));
+      last_received_sequence_number_.emplace(utils::network_to_host(field));
     }
   }
   return false;
@@ -89,7 +89,7 @@ observe_seqno_request_body::fill_body()
 
   value_.resize(sizeof(std::uint64_t));
 
-  std::uint64_t field = utils::byte_swap(partition_uuid_);
+  std::uint64_t field = utils::host_to_network(partition_uuid_);
   memcpy(value_.data() + offset, &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_prepend.cxx

@@ -41,12 +41,12 @@ prepend_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;

data/ext/couchbase/core/protocol/cmd_remove.cxx

@@ -42,12 +42,12 @@ remove_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;

data/ext/couchbase/core/protocol/cmd_replace.cxx

@@ -42,12 +42,12 @@ replace_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;
@@ -83,10 +83,10 @@ replace_request_body::fill_extras()
 {
   extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
-  std::uint32_t field = utils::byte_swap(flags_);
+  std::uint32_t field = utils::host_to_network(flags_);
   memcpy(extras_.data(), &field, sizeof(field));
 
-  field = utils::byte_swap(expiry_);
+  field = utils::host_to_network(expiry_);
   memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_touch.cxx

@@ -47,7 +47,7 @@ void
 touch_request_body::expiry(std::uint32_t seconds)
 {
   extras_.resize(sizeof(seconds));
-  seconds = utils::byte_swap(seconds);
+  seconds = utils::host_to_network(seconds);
   memcpy(extras_.data(), &seconds, sizeof(seconds));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_upsert.cxx

@@ -43,12 +43,12 @@ upsert_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;
@@ -83,10 +83,10 @@ upsert_request_body::fill_extras()
 {
   extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
-  std::uint32_t field = utils::byte_swap(flags_);
+  std::uint32_t field = utils::host_to_network(flags_);
   memcpy(extras_.data(), &field, sizeof(field));
 
-  field = utils::byte_swap(expiry_);
+  field = utils::host_to_network(expiry_);
   memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol