couchbase 3.2.0 → 3.2.4

package/deps/lcb/packaging/deb/control

@@ -6,7 +6,7 @@ Standards-Version: 3.9.2
 Section: libs
 Homepage: http://www.couchbase.com/develop/c/current
 Vcs-Browser: https://github.com/couchbase/libcouchbase
-Vcs-Git: git://github.com/couchbase/libcouchbase.git
+Vcs-Git: https://github.com/couchbase/libcouchbase.git
 
 Package: libcouchbase3-libevent
 Architecture: any

package/deps/lcb/src/analytics/analytics_handle.cc

@@ -225,7 +225,7 @@ lcb_ANALYTICS_HANDLE_::lcb_ANALYTICS_HANDLE_(lcb_INSTANCE *obj, void *user_cooki
     query_params_ = Json::FastWriter().write(cmd->root());
 
     if (instance_->settings->tracer) {
-        span_ = cmd->parent_span();
+        parent_span_ = cmd->parent_span();
     }
 
     if (ingest_options().method != LCB_INGEST_METHOD_NONE) {
@@ -237,6 +237,9 @@ lcb_ANALYTICS_HANDLE_::lcb_ANALYTICS_HANDLE_(lcb_INSTANCE *obj, void *user_cooki
         // TODO: docq->max_pending_response;
         lcb_aspend_add(&instance_->pendops, LCB_PENDTYPE_COUNTER, nullptr);
     }
+    if (cmd->want_impersonation()) {
+        impostor_ = cmd->impostor();
+    }
 }
 
 lcb_ANALYTICS_HANDLE_::lcb_ANALYTICS_HANDLE_(lcb_INSTANCE *obj, void *user_cookie, lcb_DEFERRED_HANDLE *handle)
@@ -277,9 +280,11 @@ lcb_STATUS lcb_ANALYTICS_HANDLE_::issue_htreq(const std::string &body)
     if (!hostname.empty()) {
         lcb_cmdhttp_host(htcmd, hostname.c_str(), hostname.size());
     }
+    if (!impostor_.empty()) {
+        htcmd->set_header("cb-on-behalf-of", impostor_);
+    }
 
-    LCBTRACE_HTTP_START(instance_->settings, client_context_id_.c_str(), span_, LCBTRACE_TAG_SERVICE_ANALYTICS,
-                        LCBTRACE_THRESHOLD_ANALYTICS, span_);
+    span_ = lcb::trace::start_http_span_with_statement(instance_->settings, this, statement_);
     lcb_cmdhttp_parent_span(htcmd, span_);
 
     lcb_STATUS rc = lcb_http(instance_, this, htcmd);
@@ -388,7 +393,7 @@ void lcb_ANALYTICS_HANDLE_::invoke_row(lcb_RESPANALYTICS *resp, bool is_last)
             resp->rflags |= LCB_RESP_F_EXTDATA;
         }
         Json::Value meta;
-        if (Json::Reader().parse(resp->row, resp->row + resp->nrow, meta)) {
+        if (Json::Reader(Json::Features::strictMode()).parse(resp->row, resp->row + resp->nrow, meta)) {
             const Json::Value &errors = meta["errors"];
             if (errors.isArray() && !errors.empty()) {
                 const Json::Value &err = errors[0];
@@ -450,7 +455,10 @@ void lcb_ANALYTICS_HANDLE_::invoke_row(lcb_RESPANALYTICS *resp, bool is_last)
             }
         }
 
-        LCBTRACE_HTTP_FINISH(span_);
+        if (span_ != nullptr) {
+            lcb::trace::finish_http_span(span_, this);
+            span_ = nullptr;
+        }
         if (http_request_ != nullptr) {
             http_request_->span = nullptr;
         }

package/deps/lcb/src/analytics/analytics_handle.hh

@@ -208,6 +208,32 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
         return last_error_;
     }
 
+    static lcbtrace_THRESHOLDOPTS service()
+    {
+        return LCBTRACE_THRESHOLD_ANALYTICS;
+    }
+
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_ANALYTICS;
+        return name;
+    }
+
+    lcbtrace_SPAN *parent_span() const
+    {
+        return parent_span_;
+    }
+
+    const std::string &client_context_id() const
+    {
+        return client_context_id_;
+    }
+
+    int retries() const
+    {
+        return retries_;
+    }
+
   private:
     const lcb_RESPHTTP *http_response_{nullptr};
     lcb_HTTP_HANDLE *http_request_{nullptr};
@@ -219,6 +245,7 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
     lcb_U32 timeout_{0};
     // How many rows were received. Used to avoid parsing the meta
     size_t rows_number_{0};
+    int retries_{0};
 
     /** Request body as received from the application */
     Json::Value json{};
@@ -240,7 +267,9 @@ struct lcb_ANALYTICS_HANDLE_ : lcb::jsparse::Parser::Actions {
     lcb::docreq::Queue *document_queue_{nullptr};
     unsigned refcount{1};
 
+    lcbtrace_SPAN *parent_span_{nullptr};
     lcbtrace_SPAN *span_{nullptr};
+    std::string impostor_{};
 };
 
 #endif // LIBCOUCHBASE_ANALYTICS_HANDLE_HH

package/deps/lcb/src/bootstrap.cc

@@ -37,8 +37,11 @@ void Bootstrap::config_callback(EventType event, ConfigInfo *info)
     lcb_INSTANCE *instance = parent;
 
     if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
-        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
-            if (!LCBT_VBCONFIG(instance)) {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED && !LCBT_VBCONFIG(instance)) {
+            if (parent->confmon->get_last_error() == LCB_ERR_CONNECTION_REFUSED) {
+                initial_error(LCB_ERR_NO_MATCHING_SERVER,
+                              "Unable to bootstrap, check ports and cluster encryption setting");
+            } else {
                 initial_error(LCB_ERR_NO_MATCHING_SERVER, "No more bootstrap providers remain");
             }
         }
@@ -199,7 +202,7 @@ void Bootstrap::initial_error(lcb_STATUS err, const char *errinfo)
     if (parent->last_error == LCB_SUCCESS) {
         parent->last_error = err;
     }
-    lcb_log(LOGARGS(parent, ERR), "Failed to bootstrap client=%p. Error=%s (Last=%s), Message=%s", (void *)parent,
+    lcb_log(LOGARGS(parent, ERR), "Failed to bootstrap client=%p. Error=%s (Last=%s), Message=\"%s\"", (void *)parent,
             lcb_strerror_short(err), lcb_strerror_short(parent->last_error), errinfo);
     tm.cancel();
 

package/deps/lcb/src/capi/cmd_analytics.cc

@@ -222,10 +222,16 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_named_param(lcb_CMDANALYTICS *cmd,
     return cmd->option(name, name_len, value, value_len);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_positional_params(lcb_CMDANALYTICS *cmd, const char *value,
+                                                               size_t value_len)
+{
+    return cmd->option_array("args", value, value_len);
+}
+
 LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_positional_param(lcb_CMDANALYTICS *cmd, const char *value,
                                                               size_t value_len)
 {
-    return cmd->option_array("args", value, value_len);
+    return cmd->option_array_append("args", value, value_len);
 }
 
 LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_deferred(lcb_CMDANALYTICS *cmd, int deferred)
@@ -238,6 +244,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_ingest_options(lcb_CMDANALYTICS *cm
     return cmd->ingest_options(options);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdanalytics_on_behalf_of(lcb_CMDANALYTICS *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 LIBCOUCHBASE_API lcb_STATUS lcb_ingest_options_create(lcb_INGEST_OPTIONS **options)
 {
     *options = new lcb_INGEST_OPTIONS();

package/deps/lcb/src/capi/cmd_analytics.hh

@@ -222,6 +222,19 @@ struct lcb_CMDANALYTICS_ {
         return LCB_SUCCESS;
     }
 
+    lcb_STATUS option_array_append(const std::string &name, const char *value, std::size_t value_len)
+    {
+        if (name.empty() || value == nullptr) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        Json::Value json_value;
+        if (!Json::Reader().parse(value, value + value_len, json_value)) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        root_[name].append(json_value);
+        return LCB_SUCCESS;
+    }
+
     lcb_STATUS option_string(const std::string &name, const char *value, std::size_t value_len)
     {
         if (name.empty() || value == nullptr || value_len == 0) {
@@ -346,6 +359,22 @@ struct lcb_CMDANALYTICS_ {
         return priority_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     std::chrono::microseconds timeout_{0};
     std::chrono::nanoseconds start_time_{0};
@@ -359,6 +388,7 @@ struct lcb_CMDANALYTICS_ {
     bool priority_{false};
     std::string scope_qualifier_{};
     std::string scope_name_{};
+    std::string impostor_{};
 };
 
 #endif // LIBCOUCHBASE_CAPI_ANALYTICS_HH

package/deps/lcb/src/capi/cmd_counter.hh

@@ -30,6 +30,12 @@
  */
 struct lcb_CMDCOUNTER_ {
   public:
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_COUNTER;
+        return name;
+    }
+
     lcb_STATUS expiry(std::uint32_t expiry)
     {
         if (!initialize_if_does_not_exist_) {
@@ -175,6 +181,22 @@ struct lcb_CMDCOUNTER_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::uint32_t expiry_{0};
@@ -187,6 +209,7 @@ struct lcb_CMDCOUNTER_ {
     std::string key_{};
     bool initialize_if_does_not_exist_{false};
     lcb_DURABILITY_LEVEL durability_level_{LCB_DURABILITYLEVEL_NONE};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_exists.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDEXISTS_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_EXISTS;
+        return name;
+    }
+
     lcb_STATUS key(std::string key)
     {
         key_ = std::move(key);
@@ -115,13 +121,30 @@ struct lcb_CMDEXISTS_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
     std::chrono::nanoseconds start_time_{0};
     lcbtrace_SPAN *parent_span_{nullptr};
-    void *cookie_;
+    void *cookie_{nullptr};
     std::string key_{};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_get.hh

@@ -34,6 +34,11 @@ enum class get_mode {
  * @private
  */
 struct lcb_CMDGET_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_GET;
+        return name;
+    }
 
     lcb_STATUS with_touch(std::uint32_t expiry)
     {
@@ -175,6 +180,22 @@ struct lcb_CMDGET_ {
         return cookie_is_callback_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -186,6 +207,7 @@ struct lcb_CMDGET_ {
     std::string key_{};
     get_mode mode_{get_mode::normal};
     bool cookie_is_callback_{false};
+    std::string impostor_{};
 };
 
 /** @private */

package/deps/lcb/src/capi/cmd_get_replica.hh

@@ -36,6 +36,12 @@ enum class get_replica_mode {
  * @private
  */
 struct lcb_CMDGETREPLICA_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_GET_FROM_REPLICA;
+        return name;
+    }
+
     lcb_STATUS mode(get_replica_mode mode)
     {
         mode_ = mode;
@@ -150,6 +156,22 @@ struct lcb_CMDGETREPLICA_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -159,6 +181,7 @@ struct lcb_CMDGETREPLICA_ {
     std::string key_{};
     get_replica_mode mode_{get_replica_mode::any};
     int select_index_{0};
+    std::string impostor_{};
 };
 
 struct lcb_RESPGETREPLICA_ {

package/deps/lcb/src/capi/cmd_http.hh

@@ -50,6 +50,11 @@
  * Note that the key and nkey fields indicate the _path_ for the API
  */
 struct lcb_CMDHTTP_ {
+    void set_header(const std::string &name, const std::string &value)
+    {
+        headers_.emplace(name, value);
+    }
+
     /**Common flags for the command. These modify the command itself. Currently
      the lower 16 bits of this field are reserved, and the higher 16 bits are
      used for individual commands.*/
@@ -118,6 +123,8 @@ struct lcb_CMDHTTP_ {
     /** If set, this must be a string in the form of `http://host:port`. Should
      * only be used for raw requests. */
     const char *host;
+
+    std::map<std::string, std::string> headers_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_query.cc

@@ -142,11 +142,16 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_named_param(lcb_CMDQUERY *cmd, const ch
     return cmd->option("$" + std::string(name, name_len), value, value_len);
 }
 
-LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_positional_param(lcb_CMDQUERY *cmd, const char *value, size_t value_len)
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_positional_params(lcb_CMDQUERY *cmd, const char *value, size_t value_len)
 {
     return cmd->option_array("args", value, value_len);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_positional_param(lcb_CMDQUERY *cmd, const char *value, size_t value_len)
+{
+    return cmd->option_array_append("args", value, value_len);
+}
+
 LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_adhoc(lcb_CMDQUERY *cmd, int adhoc)
 {
     return cmd->prepare_statement(!adhoc);
@@ -258,6 +263,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_handle(lcb_CMDQUERY *cmd, lcb_QUERY_HAN
     return cmd->store_handle_refence_to(handle);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdquery_on_behalf_of(lcb_CMDQUERY *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 LIBCOUCHBASE_API lcb_STATUS lcb_errctx_query_rc(const lcb_QUERY_ERROR_CONTEXT *ctx)
 {
     return ctx->rc;

package/deps/lcb/src/capi/cmd_query.hh

@@ -381,6 +381,19 @@ struct lcb_CMDQUERY_ {
         return LCB_SUCCESS;
     }
 
+    lcb_STATUS option_array_append(const std::string &name, const char *value, std::size_t value_len)
+    {
+        if (name.empty() || value == nullptr) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        Json::Value json_value;
+        if (!Json::Reader().parse(value, value + value_len, json_value)) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        root_[name].append(json_value);
+        return LCB_SUCCESS;
+    }
+
     lcb_STATUS option_string(const std::string &name, const char *value, std::size_t value_len)
     {
         if (name.empty() || value == nullptr || value_len == 0) {
@@ -417,6 +430,22 @@ struct lcb_CMDQUERY_ {
         cookie_ = cookie;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     std::string scope_{};
     std::string scope_qualifier_{};
@@ -450,6 +479,8 @@ struct lcb_CMDQUERY_ {
     /**Request handle. Will be set to the handle which may be passed to
      * lcb_query_cancel() */
     lcb_QUERY_HANDLE **handle_{nullptr};
+
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_remove.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDREMOVE_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_REMOVE;
+        return name;
+    }
+
     lcb_STATUS cas(std::uint64_t cas)
     {
         cas_ = cas;
@@ -142,6 +148,22 @@ struct lcb_CMDREMOVE_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -151,6 +173,7 @@ struct lcb_CMDREMOVE_ {
     std::string key_{};
     std::uint64_t cas_{0};
     lcb_DURABILITY_LEVEL durability_level_{LCB_DURABILITYLEVEL_NONE};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_search.cc

@@ -97,6 +97,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_handle(lcb_CMDSEARCH *cmd, lcb_SEARCH_
 {
     return cmd->store_handle_refence_to(handle);
 }
+
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdsearch_on_behalf_of(lcb_CMDSEARCH *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 LIBCOUCHBASE_API lcb_STATUS lcb_errctx_search_rc(const lcb_SEARCH_ERROR_CONTEXT *ctx)
 {
     return ctx->rc;

package/deps/lcb/src/capi/cmd_search.hh

@@ -70,6 +70,12 @@ struct lcb_RESPSEARCH_ {
  * @private
  */
 struct lcb_CMDSEARCH_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_SEARCH;
+        return name;
+    }
+
     bool has_callback() const
     {
         return callback_ != nullptr;
@@ -168,6 +174,22 @@ struct lcb_CMDSEARCH_ {
         return LCB_SUCCESS;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     std::chrono::microseconds timeout_{0};
     std::chrono::nanoseconds start_time_{0};
@@ -176,6 +198,7 @@ struct lcb_CMDSEARCH_ {
     void *cookie_{nullptr};
     lcb_SEARCH_CALLBACK callback_{nullptr};
     lcb_SEARCH_HANDLE **handle_{nullptr};
+    std::string impostor_{};
 };
 
 #endif // LIBCOUCHBASE_CAPI_SEARCH_HH

package/deps/lcb/src/capi/cmd_store.hh

@@ -35,6 +35,16 @@ enum class durability_mode {
  * @private
  */
 struct lcb_CMDSTORE_ {
+    const std::string &operation_name() const
+    {
+        static std::map<int, std::string> names{
+            {LCB_STORE_UPSERT, LCBTRACE_OP_UPSERT}, {LCB_STORE_REPLACE, LCBTRACE_OP_REPLACE},
+            {LCB_STORE_APPEND, LCBTRACE_OP_APPEND}, {LCB_STORE_PREPEND, LCBTRACE_OP_PREPEND},
+            {LCB_STORE_INSERT, LCBTRACE_OP_INSERT},
+        };
+        return names[operation_];
+    }
+
     lcb_STATUS operation(lcb_STORE_OPERATION operation)
     {
         operation_ = operation;
@@ -123,24 +133,6 @@ struct lcb_CMDSTORE_ {
         return false;
     }
 
-    const char *operation_name() const
-    {
-        switch (operation_) {
-            case LCB_STORE_UPSERT:
-                return LCBTRACE_OP_UPSERT;
-            case LCB_STORE_REPLACE:
-                return LCBTRACE_OP_REPLACE;
-            case LCB_STORE_APPEND:
-                return LCBTRACE_OP_APPEND;
-            case LCB_STORE_PREPEND:
-                return LCBTRACE_OP_PREPEND;
-            case LCB_STORE_INSERT:
-                return LCBTRACE_OP_INSERT;
-        }
-        lcb_assert(false && "unknown operation name");
-        return "unknown";
-    }
-
     lcb_STATUS flags(std::uint32_t flags)
     {
         if (operation_ == LCB_STORE_APPEND || operation_ == LCB_STORE_PREPEND) {
@@ -245,13 +237,16 @@ struct lcb_CMDSTORE_ {
 
     lcb_STATUS value(const lcb_IOV *iov, std::size_t iov_len)
     {
-        std::stringstream ss;
+        std::size_t total_size = 0;
+        for (std::size_t i = 0; i < iov_len; ++i) {
+            total_size += iov[i].iov_len;
+        }
+        value_.reserve(total_size);
         for (std::size_t i = 0; i < iov_len; ++i) {
             if (iov[i].iov_len > 0 && iov[i].iov_base != nullptr) {
-                ss << std::string(static_cast<const char *>(iov[i].iov_base), iov[i].iov_len);
+                value_.append(static_cast<const char *>(iov[i].iov_base), iov[i].iov_len);
             }
         }
-        value_ = ss.str();
         return LCB_SUCCESS;
     }
 
@@ -370,6 +365,22 @@ struct lcb_CMDSTORE_ {
         return preserve_expiry_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -390,6 +401,7 @@ struct lcb_CMDSTORE_ {
     bool compressed_{false};
     bool cookie_is_callback_{false};
     bool preserve_expiry_{false};
+    std::string impostor_{};
 };
 
 /**