couchbase 3.2.4 → 3.2.6

package/deps/lcb/tests/iotests/testutil.cc

@@ -629,3 +629,177 @@ void TestMeter::destroy_lcb_meter()
         lcbmeter_ = nullptr;
     }
 }
+
+void enforce_rate_limits(lcb_INSTANCE *instance)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/internalSettings";
+    std::string body = "enforceLimits=true";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_POST);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_rate_limited_user(lcb_INSTANCE *instance, const std::string &username, const rate_limits &limits)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/settings/rbac/users/local/" + username;
+    std::string body = "password=password&roles=admin";
+    Json::Value json_limits;
+    if (limits.kv_limits.enforce) {
+        Json::Value kv_limits;
+        if (limits.kv_limits.num_connections > 0) {
+            kv_limits["num_connections"] = limits.kv_limits.num_connections;
+        }
+        if (limits.kv_limits.num_ops_per_min > 0) {
+            kv_limits["num_ops_per_min"] = limits.kv_limits.num_ops_per_min;
+        }
+        if (limits.kv_limits.ingress_mib_per_min > 0) {
+            kv_limits["ingress_mib_per_min"] = limits.kv_limits.ingress_mib_per_min;
+        }
+        if (limits.kv_limits.egress_mib_per_min > 0) {
+            kv_limits["egress_mib_per_min"] = limits.kv_limits.egress_mib_per_min;
+        }
+        json_limits["kv"] = kv_limits;
+    }
+    if (limits.query_limits.enforce) {
+        Json::Value query_limits;
+        if (limits.query_limits.num_concurrent_requests > 0) {
+            query_limits["num_concurrent_requests"] = limits.query_limits.num_concurrent_requests;
+        }
+        if (limits.query_limits.num_queries_per_min > 0) {
+            query_limits["num_queries_per_min"] = limits.query_limits.num_queries_per_min;
+        }
+        if (limits.query_limits.ingress_mib_per_min > 0) {
+            query_limits["ingress_mib_per_min"] = limits.query_limits.ingress_mib_per_min;
+        }
+        if (limits.query_limits.egress_mib_per_min > 0) {
+            query_limits["egress_mib_per_min"] = limits.query_limits.egress_mib_per_min;
+        }
+        json_limits["query"] = query_limits;
+    }
+    if (limits.search_limits.enforce) {
+        Json::Value fts_limits;
+        if (limits.search_limits.num_concurrent_requests > 0) {
+            fts_limits["num_concurrent_requests"] = limits.search_limits.num_concurrent_requests;
+        }
+        if (limits.search_limits.num_queries_per_min > 0) {
+            fts_limits["num_queries_per_min"] = limits.search_limits.num_queries_per_min;
+        }
+        if (limits.search_limits.ingress_mib_per_min > 0) {
+            fts_limits["ingress_mib_per_min"] = limits.search_limits.ingress_mib_per_min;
+        }
+        if (limits.search_limits.egress_mib_per_min > 0) {
+            fts_limits["egress_mib_per_min"] = limits.search_limits.egress_mib_per_min;
+        }
+        json_limits["fts"] = fts_limits;
+    }
+    std::string j_limits = Json::FastWriter().write(json_limits);
+    body += "&limits=" + j_limits;
+    std::string content_type = "application/x-www-form-urlencoded";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_PUT);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+    lcb_cmdhttp_content_type(cmd, content_type.c_str(), content_type.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_rate_limited_scope(lcb_INSTANCE *instance, const std::string &bucket, std::string &scope,
+                               const scope_rate_limits &limits)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/pools/default/buckets/" + bucket + "/scopes";
+    std::string body = "name=" + scope;
+    Json::Value json_limits;
+    if (limits.kv_scope_limits.enforce) {
+        Json::Value kv_limits;
+        kv_limits["data_size"] = limits.kv_scope_limits.data_size;
+        json_limits["kv"] = kv_limits;
+    }
+    if (limits.index_scope_limits.enforce) {
+        Json::Value index_limits;
+        index_limits["num_indexes"] = limits.index_scope_limits.num_indexes;
+        json_limits["index"] = index_limits;
+    }
+    std::string j_limits = Json::FastWriter().write(json_limits);
+    body += "&limits=" + j_limits;
+    std::string content_type = "application/x-www-form-urlencoded";
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_POST);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+    lcb_cmdhttp_content_type(cmd, content_type.c_str(), content_type.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void drop_user(lcb_INSTANCE *instance, const std::string &username)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/settings/rbac/users/local/" + username;
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_MANAGEMENT);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_DELETE);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}
+
+void create_search_index(lcb_INSTANCE *instance, const std::string &index_name, const std::string &type,
+                         const std::string &source_type, const std::string &source_name)
+{
+    (void)lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)http_callback);
+
+    lcb_CMDHTTP *cmd;
+    std::string path = "/api/index/" + index_name;
+    Json::Value json_body;
+    json_body["name"] = index_name;
+    json_body["type"] = type;
+    json_body["sourceName"] = source_name;
+    json_body["sourceType"] = source_type;
+
+    auto body = Json::FastWriter().write(json_body);
+
+    lcb_cmdhttp_create(&cmd, LCB_HTTP_TYPE_SEARCH);
+    lcb_cmdhttp_method(cmd, LCB_HTTP_METHOD_PUT);
+    lcb_cmdhttp_path(cmd, path.c_str(), path.size());
+    lcb_cmdhttp_body(cmd, body.c_str(), body.size());
+
+    http_result result{};
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_http(instance, &result, cmd));
+    lcb_cmdhttp_destroy(cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, result.rc);
+}

package/deps/lcb/tests/iotests/testutil.h

@@ -323,4 +323,57 @@ class TestMeter
     bool enabled_{false};
 };
 
+struct kv_rate_limits {
+    uint32_t num_connections{0};
+    uint32_t num_ops_per_min{0};
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    bool enforce{false};
+};
+
+struct query_rate_limits {
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    uint32_t num_concurrent_requests{0};
+    uint32_t num_queries_per_min{0};
+    bool enforce{false};
+};
+
+struct search_rate_limits {
+    uint32_t ingress_mib_per_min{0};
+    uint32_t egress_mib_per_min{0};
+    uint32_t num_concurrent_requests{0};
+    uint32_t num_queries_per_min{0};
+    bool enforce{false};
+};
+
+struct rate_limits {
+    kv_rate_limits kv_limits{};
+    query_rate_limits query_limits{};
+    search_rate_limits search_limits{};
+};
+
+struct kv_scope_rate_limits {
+    uint32_t data_size;
+    bool enforce{false};
+};
+
+struct index_scope_rate_limits {
+    uint32_t num_indexes{0};
+    bool enforce{false};
+};
+
+struct scope_rate_limits {
+    kv_scope_rate_limits kv_scope_limits;
+    index_scope_rate_limits index_scope_limits;
+};
+
+void enforce_rate_limits(lcb_INSTANCE *instance);
+void create_rate_limited_user(lcb_INSTANCE *instance, const std::string &username, const rate_limits &limits);
+void drop_user(lcb_INSTANCE *instance, const std::string &username);
+void create_rate_limited_scope(lcb_INSTANCE *instance, const std::string &bucket, std::string &scope,
+                               const scope_rate_limits &limits);
+void create_search_index(lcb_INSTANCE *instance, const std::string &index_name, const std::string &type,
+                         const std::string &source_type, const std::string &source_name);
+
 #endif

package/deps/lcb/tools/CMakeLists.txt

@@ -75,7 +75,7 @@ IF(NOT WIN32)
     LIST(APPEND CBC_SUBCOMMANDS
         cat create observe observe-seqno incr decr hash lock
         unlock rm stats version verbosity view n1ql admin ping
-        bucket-create bucket-delete bucket-flush connstr write-config strerror
+        bucket-list bucket-create bucket-delete bucket-flush connstr write-config strerror
         touch role-list user-list user-upsert user-delete watch
         mcversion keygen collection-manifest collection-id
         )

package/deps/lcb/tools/cbc-handlers.h

@@ -827,6 +827,45 @@ class UserUpsertHandler : public AdminHandler
     std::string body;
 };
 
+class BucketListHandler : public AdminHandler
+{
+  public:
+    HANDLER_DESCRIPTION("List buckets")
+    HANDLER_USAGE("NAME [OPTIONS ...]")
+    BucketListHandler() : AdminHandler("bucket-list"), o_raw('r', "raw")
+    {
+        o_raw.description("Do not reformat output from server (display JSON response)");
+    }
+
+  protected:
+    void run() override;
+    void format();
+
+    void addOptions() override
+    {
+        AdminHandler::addOptions();
+        parser.addOption(o_raw);
+    }
+
+    std::string getURI() override
+    {
+        return "/pools/default/buckets";
+    }
+
+    std::string getContentType() override
+    {
+        return "application/json";
+    }
+    
+    lcb_HTTP_METHOD getMethod() override
+    {
+        return LCB_HTTP_METHOD_GET;
+    }
+
+  private:
+    cliopts::BoolOption o_raw;
+};
+
 class BucketCreateHandler : public AdminHandler
 {
   public:

package/deps/lcb/tools/cbc-n1qlback.cc

@@ -458,6 +458,7 @@ class ThreadContext
         lcb_STATUS rc = lcb_query(m_instance, &qctx, m_cmd);
         if (rc != LCB_SUCCESS) {
             log_error(rc, query.payload.c_str(), query.payload.size());
+            lcb_tick_nowait(m_instance);
         } else {
             lcb_wait(m_instance, LCB_WAIT_DEFAULT);
             m_metrics.lock();

package/deps/lcb/tools/cbc-pillowfight.cc

@@ -104,7 +104,7 @@ class Configuration
           o_startAt("start-at"), o_rateLimit("rate-limit"), o_userdocs("docs"), o_writeJson("json"),
           o_templatePairs("template"), o_subdoc("subdoc"), o_noop("noop"), o_sdPathCount("pathcount"),
           o_populateOnly("populate-only"), o_exptime("expiry"), o_collection("collection"), o_durability("durability"),
-          o_persist("persist-to"), o_replicate("replicate-to"), o_lock("lock")
+          o_persist("persist-to"), o_replicate("replicate-to"), o_lock("lock"), o_randSpace("rand-space-per-thread")
     {
         o_multiSize.setDefault(100).abbrev('B').description("Number of operations to batch");
         o_numItems.setDefault(1000).abbrev('I').description("Number of items to operate on");
@@ -138,6 +138,8 @@ class Configuration
         o_replicate.description("Wait until item is replicated to this number of nodes (-1 for all replicas)")
             .setDefault(0);
         o_lock.description("Lock keys for updates for given time (will not lock when set to zero)").setDefault(0);
+        o_randSpace.description("When set and --sequential is not set, threads will perform operations on different key"
+                                " spaces").setDefault(false);
         params.getTimings().description("Enable command timings (second time to dump timings automatically)");
     }
 
@@ -218,25 +220,25 @@ class Configuration
 
         if (specs.empty()) {
             if (o_writeJson.result()) {
-                docgen = new JsonDocGenerator(o_minSize.result(), o_maxSize.result(), o_randomBody.numSpecified());
+                docgen.reset(new JsonDocGenerator(o_minSize.result(), o_maxSize.result(), o_randomBody.numSpecified()));
             } else if (!userdocs.empty()) {
-                docgen = new PresetDocGenerator(userdocs);
+                docgen.reset(new PresetDocGenerator(userdocs));
             } else {
-                docgen = new RawDocGenerator(o_minSize.result(), o_maxSize.result(), o_randomBody.numSpecified());
+                docgen.reset(new RawDocGenerator(o_minSize.result(), o_maxSize.result(), o_randomBody.numSpecified()));
             }
         } else {
             if (o_writeJson.result()) {
                 if (userdocs.empty()) {
-                    docgen = new PlaceholderJsonGenerator(o_minSize.result(), o_maxSize.result(), specs,
-                                                          o_randomBody.numSpecified());
+                    docgen.reset(new PlaceholderJsonGenerator(o_minSize.result(), o_maxSize.result(), specs,
+                                                          o_randomBody.numSpecified()));
                 } else {
-                    docgen = new PlaceholderJsonGenerator(userdocs, specs);
+                    docgen.reset(new PlaceholderJsonGenerator(userdocs, specs));
                 }
             } else {
                 if (userdocs.empty()) {
                     throw std::runtime_error("Must provide documents with placeholders!");
                 }
-                docgen = new PlaceholderDocGenerator(userdocs, specs);
+                docgen.reset(new PlaceholderDocGenerator(userdocs, specs));
             }
         }
 
@@ -279,6 +281,7 @@ class Configuration
         parser.addOption(o_persist);
         parser.addOption(o_replicate);
         parser.addOption(o_lock);
+        parser.addOption(o_randSpace);
         params.addToParser(parser);
         depr.addOptions(parser);
     }
@@ -357,6 +360,10 @@ class Configuration
     {
         return o_exptime;
     }
+    bool useRandSpacePerThread()
+    {
+        return o_randSpace;
+    }
 
     uint32_t opsPerCycle{};
     uint32_t sdOpsPerCmd{};
@@ -365,7 +372,7 @@ class Configuration
     volatile int maxCycles{};
     bool shouldPopulate{};
     ConnParams params;
-    const DocGeneratorBase *docgen{};
+    std::unique_ptr<DocGeneratorBase> docgen;
     vector<string> collections{};
     lcb_DURABILITY_LEVEL durabilityLevel{LCB_DURABILITYLEVEL_NONE};
     int replicateTo{};
@@ -411,6 +418,7 @@ class Configuration
     IntOption o_replicate;
 
     IntOption o_lock;
+    BoolOption o_randSpace;
     DeprecatedOptions depr;
 } config;
 
@@ -569,12 +577,14 @@ class KeyGenerator : public OpGenerator
     explicit KeyGenerator(int ix)
         : OpGenerator(ix), m_gencount(0), m_force_sequential(false), m_in_population(config.shouldPopulate)
     {
-        srand(config.getRandomSeed());
+        if(!config.useRandSpacePerThread()) {
+            srand(config.getRandomSeed());
+        }
 
-        m_genrandom = new SeqGenerator(config.firstKeyOffset(), config.getNumItems() + config.firstKeyOffset());
+        m_genrandom.reset(new SeqGenerator(config.firstKeyOffset(), config.getNumItems() + config.firstKeyOffset()));
 
-        m_gensequence = new SeqGenerator(config.firstKeyOffset(), config.getNumItems() + config.firstKeyOffset(),
-                                         config.getNumThreads(), ix);
+        m_gensequence.reset(new SeqGenerator(config.firstKeyOffset(), config.getNumItems() + config.firstKeyOffset(),
+                                         config.getNumThreads(), ix));
 
         if (m_in_population) {
             m_force_sequential = true;
@@ -701,16 +711,16 @@ class KeyGenerator : public OpGenerator
         }
     }
 
-    SeqGenerator *m_genrandom;
-    SeqGenerator *m_gensequence;
+    std::unique_ptr<SeqGenerator> m_genrandom;
+    std::unique_ptr<SeqGenerator> m_gensequence;
     size_t m_gencount;
 
     bool m_force_sequential;
     bool m_in_population;
     NextOp::Mode m_mode_read;
     NextOp::Mode m_mode_write;
-    GeneratorState *m_local_genstate;
-    SubdocGeneratorState *m_sdgenstate;
+    std::unique_ptr<GeneratorState> m_local_genstate;
+    std::unique_ptr<SubdocGeneratorState> m_sdgenstate;
 };
 
 #define OPFLAGS_LOCKED 0x01
@@ -721,16 +731,15 @@ class ThreadContext
     ThreadContext(lcb_INSTANCE *handle, int ix) : niter(0), instance(handle)
     {
         if (config.isNoop()) {
-            gen = new NoopGenerator(ix);
+            gen.reset(new NoopGenerator(ix));
         } else {
-            gen = new KeyGenerator(ix);
+            gen.reset(new KeyGenerator(ix));
         }
     }
 
     ~ThreadContext()
     {
-        delete gen;
-        gen = nullptr;
+        lcb_destroy(instance);
     }
 
     bool inPopulation()
@@ -993,7 +1002,7 @@ class ThreadContext
         previous_time = now;
     }
 
-    OpGenerator *gen;
+    std::unique_ptr<OpGenerator> gen;
     size_t niter;
     lcb_STATUS error{LCB_SUCCESS};
     lcb_INSTANCE *instance{nullptr};
@@ -1197,7 +1206,8 @@ static void storeCallback(lcb_INSTANCE *instance, int, const lcb_RESPSTORE *resp
     updateOpsPerSecDisplay();
 }
 
-std::list<ThreadContext *> contexts;
+std::list<InstanceCookie> cookies;
+std::list<ThreadContext> contexts;
 
 extern "C" {
 typedef void (*handler_t)(int);
@@ -1205,8 +1215,8 @@ typedef void (*handler_t)(int);
 static void dump_metrics()
 {
     std::list<ThreadContext *>::iterator it;
-    for (it = contexts.begin(); it != contexts.end(); ++it) {
-        lcb_INSTANCE *instance = (*it)->getInstance();
+    for (auto& context : contexts) {
+        lcb_INSTANCE *instance = context.getInstance();
         lcb_CMDDIAG *req;
         lcb_cmddiag_create(&req);
         lcb_cmddiag_prettify(req, true);
@@ -1284,10 +1294,6 @@ static void sigint_handler(int)
         return;
     }
 
-    std::list<ThreadContext *>::iterator it;
-    for (it = contexts.begin(); it != contexts.end(); ++it) {
-        delete *it;
-    }
     contexts.clear();
     exit(EXIT_FAILURE);
 }
@@ -1315,10 +1321,10 @@ static void start_worker(ThreadContext *ctx)
         exit(EXIT_FAILURE);
     }
 }
-static void join_worker(ThreadContext *ctx)
+static void join_worker(ThreadContext& ctx)
 {
     void *arg = nullptr;
-    int rc = pthread_join(ctx->thr, &arg);
+    int rc = pthread_join(ctx.thr, &arg);
     if (rc != 0) {
         log("Couldn't join thread (%d)", errno);
         exit(EXIT_FAILURE);
@@ -1332,7 +1338,7 @@ static void start_worker(ThreadContext *ctx)
 {
     ctx->run();
 }
-static void join_worker(ThreadContext *ctx)
+static void join_worker(ThreadContext& ctx)
 {
     (void)ctx;
 }
@@ -1373,6 +1379,9 @@ int main(int argc, char **argv)
         nthreads = 1;
     }
 #endif
+    if(config.useRandSpacePerThread()) {
+        srand(config.getRandomSeed());
+    }
 
     lcb_CREATEOPTS *options = nullptr;
     ConnParams &cp = config.params;
@@ -1406,7 +1415,8 @@ int main(int argc, char **argv)
             lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_ENABLE_COLLECTIONS, &use);
         }
 
-        auto *cookie = new InstanceCookie(instance);
+        cookies.emplace_back(instance);
+        auto* cookie = &cookies.back();
 
         lcb_connect(instance);
         lcb_wait(instance, LCB_WAIT_DEFAULT);
@@ -1418,9 +1428,9 @@ int main(int argc, char **argv)
             exit(EXIT_FAILURE);
         }
 
-        auto *ctx = new ThreadContext(instance, ii);
+        contexts.emplace_back(instance, ii);
+        auto* ctx = &contexts.back();
         cookie->setContext(ctx);
-        contexts.push_back(ctx);
         start_worker(ctx);
     }
 

package/deps/lcb/tools/cbc.cc

@@ -2023,6 +2023,35 @@ void AdminHandler::run()
     printf("%s\n", resbuf.c_str());
 }
 
+void BucketListHandler::run()
+{
+    fprintf(stderr, "Requesting %s\n", getURI().c_str());
+    HttpBaseHandler::run();
+    if (o_raw.result()) {
+        printf("%s\n", resbuf.c_str());
+    } else {
+        format();
+    }
+}
+
+void BucketListHandler::format()
+{
+    Json::Value json;
+    if (!Json::Reader().parse(resbuf, json)) {
+        fprintf(stderr, "Failed to parse response as JSON, falling back to raw mode\n");
+        printf("%s\n", resbuf.c_str());
+    }
+
+    printf("%-20s%-10s%s\n", "Name", "Type", "Items");
+
+    for (Json::Value::ArrayIndex i = 0; i < json.size(); ++i) {
+        const char *name = json[i]["name"].asString().c_str();
+        const char *bucketType = json[i]["bucketType"].asString().c_str();
+        const int itemCount = json[i]["basicStats"]["itemCount"].asInt();
+        printf("%-20s%-10s%i\n", name, bucketType, itemCount);
+    }
+}
+
 void BucketCreateHandler::run()
 {
     const string &name = getRequiredArg();
@@ -2278,6 +2307,7 @@ static const char *optionsOrder[] = {"help",
                                      "analytics",
                                      "search",
                                      "admin",
+                                     "bucket-list",
                                      "bucket-create",
                                      "bucket-delete",
                                      "bucket-flush",
@@ -2369,6 +2399,7 @@ static void setupHandlers()
     handlers_s["incr"] = new IncrHandler();
     handlers_s["decr"] = new DecrHandler();
     handlers_s["admin"] = new AdminHandler();
+    handlers_s["bucket-list"] = new BucketListHandler();
     handlers_s["bucket-create"] = new BucketCreateHandler();
     handlers_s["bucket-delete"] = new BucketDeleteHandler();
     handlers_s["bucket-flush"] = new BucketFlushHandler();

package/deps/lcb/tools/docgen/docgen.h

@@ -18,6 +18,7 @@
 #include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
 #include "placeholders.h"
 #include <algorithm>
+#include <memory>
 #include <stdexcept>
 
 namespace Pillowfight
@@ -78,8 +79,8 @@ class DocGeneratorBase
      * @param cur_gen The index of the current generator thread
      * @return An opaque state object. This should be deleted by the caller
      */
-    virtual GeneratorState *createState(int total_gens, int cur_gen) const = 0;
-    virtual SubdocGeneratorState *createSubdocState(int, int) const
+    virtual std::unique_ptr<GeneratorState> createState(int total_gens, int cur_gen) const = 0;
+    virtual std::unique_ptr<SubdocGeneratorState> createSubdocState(int, int) const
     {
         return NULL;
     }
@@ -164,9 +165,9 @@ class RawDocGenerator : public DocGeneratorBase
         }
     };
 
-    GeneratorState *createState(int, int) const
+    std::unique_ptr<GeneratorState> createState(int, int) const
     {
-        return new MyState(this);
+        return std::unique_ptr<GeneratorState>(new MyState(this));
     }
 
   private:
@@ -207,9 +208,9 @@ class PresetDocGenerator : public DocGeneratorBase
         const PresetDocGenerator *m_parent;
     };
 
-    GeneratorState *createState(int, int) const
+    std::unique_ptr<GeneratorState> createState(int, int) const
     {
-        return new MyState(this);
+        return std::unique_ptr<GeneratorState>(new MyState(this));
     }
 
   protected:
@@ -371,9 +372,9 @@ class JsonDocGenerator : public PresetDocGenerator
     };
 
   public:
-    virtual SubdocGeneratorState *createSubdocState(int, int) const
+    virtual std::unique_ptr<SubdocGeneratorState> createSubdocState(int, int) const
     {
-        return new SDGenstate(m_docs);
+        return std::unique_ptr<SubdocGeneratorState>(new SDGenstate(m_docs));
     }
 };
 
@@ -424,9 +425,9 @@ class PlaceholderDocGenerator : public DocGeneratorBase
     }
 
   public:
-    GeneratorState *createState(int total, int cur) const
+    std::unique_ptr<GeneratorState> createState(int total, int cur) const
     {
-        return new MyState(this, total, cur);
+        return std::unique_ptr<GeneratorState>(new MyState(this, total, cur));
     }
 
   private:

package/dist/analyticsexecutor.js

@@ -82,8 +82,8 @@ class AnalyticsExecutor {
                 }
                 const metricsData = metaData.metrics || {};
                 const metrics = new analyticstypes_1.AnalyticsMetrics({
-                    elapsedTime: utilities_1.goDurationStrToMs(metricsData.elapsedTime) || 0,
-                    executionTime: utilities_1.goDurationStrToMs(metricsData.executionTime) || 0,
+                    elapsedTime: (0, utilities_1.goDurationStrToMs)(metricsData.elapsedTime) || 0,
+                    executionTime: (0, utilities_1.goDurationStrToMs)(metricsData.executionTime) || 0,
                     resultCount: metricsData.resultCount || 0,
                     resultSize: metricsData.resultSize || 0,
                     errorCount: metricsData.errorCount || 0,