couchbase 3.2.5 → 3.2.6

package/deps/lcb/src/ssl/ssl_common.c

@@ -32,6 +32,26 @@
 #define LOGARGS(ssl, lvl) ((lcbio_SOCKET *)SSL_get_app_data(ssl))->settings, "SSL", lvl, __FILE__, __LINE__
 static char *global_event = "dummy event for ssl";
 
+static const char *capella_ca_cert = "-----BEGIN CERTIFICATE-----\n"
+                                     "MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw\n"
+                                     "JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy\n"
+                                     "MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG\n"
+                                     "A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi\n"
+                                     "enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85\n"
+                                     "Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU\n"
+                                     "WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6\n"
+                                     "rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn\n"
+                                     "mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j\n"
+                                     "KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\n"
+                                     "FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\n"
+                                     "AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8\n"
+                                     "m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY\n"
+                                     "xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P\n"
+                                     "Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA\n"
+                                     "fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi\n"
+                                     "DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==\n"
+                                     "-----END CERTIFICATE-----\n";
+
 /******************************************************************************
  ******************************************************************************
  ** Boilerplate lcbio_TABLE Wrappers                                         **
@@ -221,6 +241,9 @@ static void log_callback(const SSL *ssl, int where, int ret)
 {
     int should_log = 0;
     lcbio_SOCKET *sock = SSL_get_app_data(ssl);
+    if (sock == NULL) {
+        return;
+    }
     /* Ignore low-level SSL stuff */
 
     if (where & SSL_CB_ALERT) {
@@ -298,6 +321,48 @@ static long decode_ssl_protocol(const char *protocol)
     return disallow;
 }
 
+static lcb_STATUS add_certificate_authority(const lcb_settings *settings, SSL_CTX *ctx, const char *certificate_value,
+                                            int certificate_length)
+{
+    lcb_STATUS rc = LCB_SUCCESS;
+    ERR_clear_error();
+
+    BIO *bio = BIO_new_mem_buf(certificate_value, certificate_length);
+    if (bio) {
+        X509_STORE *store = SSL_CTX_get_cert_store(ctx);
+        if (store) {
+            for (int added = 0;; added = 1) {
+                X509 *cert = PEM_read_bio_X509(bio, 0, 0, 0);
+                if (!cert) {
+                    unsigned long err = ERR_get_error();
+                    if (added && ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE) {
+                        break;
+                    }
+                    lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR),
+                            "Unable to load default certificate: lib=%s, func=%s, reason=%s", ERR_lib_error_string(err),
+                            ERR_func_error_string(err), ERR_reason_error_string(err));
+                    rc = LCB_ERR_SSL_ERROR;
+                    goto GT_CLEANUP;
+                }
+
+                int ok = X509_STORE_add_cert(store, cert);
+                X509_free(cert);
+                if (ok != 1) {
+                    unsigned long err = ERR_get_error();
+                    lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR),
+                            "Unable to add default certificate: lib=%s, func=%s, reason=%s", ERR_lib_error_string(err),
+                            ERR_func_error_string(err), ERR_reason_error_string(err));
+                    rc = LCB_ERR_SSL_ERROR;
+                    goto GT_CLEANUP;
+                }
+            }
+        }
+    }
+GT_CLEANUP:
+    BIO_free(bio);
+    return rc;
+}
+
 lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *keyfile, int noverify, lcb_STATUS *errp,
                             lcb_settings *settings)
 {
@@ -351,28 +416,41 @@ lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *
     }
 #endif
 
-    if (cafile || tsfile) {
+    if (tsfile) {
         lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Load verify locations from \"%s\"", tsfile ? tsfile : cafile);
         if (!SSL_CTX_load_verify_locations(ret->ctx, tsfile ? tsfile : cafile, NULL)) {
             *errp = LCB_ERR_SSL_ERROR;
             goto GT_ERR;
         }
-        if (cafile && keyfile) {
-            lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Authenticate with key \"%s\", cert \"%s\"", keyfile, cafile);
-            if (!SSL_CTX_use_certificate_chain_file(ret->ctx, cafile)) {
-                *errp = LCB_ERR_SSL_ERROR;
-                goto GT_ERR;
-            }
-            if (!SSL_CTX_use_PrivateKey_file(ret->ctx, keyfile, SSL_FILETYPE_PEM)) {
-                lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to load private key \"%s\"", keyfile);
-                *errp = LCB_ERR_SSL_ERROR;
-                goto GT_ERR;
-            }
-            if (!SSL_CTX_check_private_key(ret->ctx)) {
-                lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to verify private key \"%s\"", keyfile);
-                *errp = LCB_ERR_SSL_ERROR;
-                goto GT_ERR;
-            }
+    } else {
+        lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Use default CA for TLS verify");
+        if (SSL_CTX_set_default_verify_paths(ret->ctx) != 1) {
+            unsigned long err = ERR_get_error();
+            lcb_log(LOGARGS_S(settings, LCB_LOG_WARN), "Unable to load system certificates: lib=%s, reason=%s",
+                    ERR_lib_error_string(err), ERR_reason_error_string(err));
+        }
+        // add the capella Root CA if no other CA was specified.
+        *errp = add_certificate_authority(settings, ret->ctx, capella_ca_cert, strlen(capella_ca_cert));
+        if (*errp != LCB_SUCCESS) {
+            goto GT_ERR;
+        }
+    }
+
+    if (cafile && keyfile) {
+        lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Authenticate with key \"%s\", cert \"%s\"", keyfile, cafile);
+        if (!SSL_CTX_use_certificate_chain_file(ret->ctx, cafile)) {
+            *errp = LCB_ERR_SSL_ERROR;
+            goto GT_ERR;
+        }
+        if (!SSL_CTX_use_PrivateKey_file(ret->ctx, keyfile, SSL_FILETYPE_PEM)) {
+            lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to load private key \"%s\"", keyfile);
+            *errp = LCB_ERR_SSL_ERROR;
+            goto GT_ERR;
+        }
+        if (!SSL_CTX_check_private_key(ret->ctx)) {
+            lcb_log(LOGARGS_S(settings, LCB_LOG_ERROR), "Unable to verify private key \"%s\"", keyfile);
+            *errp = LCB_ERR_SSL_ERROR;
+            goto GT_ERR;
         }
     }
 
@@ -422,15 +500,25 @@ GT_ERR:
     return NULL;
 }
 
+struct proto_ctx_ssl {
+    lcbio_PROTOCTX proto;
+    SSL *ssl;
+};
+
 static void noop_dtor(lcbio_PROTOCTX *arg)
 {
-    free(arg);
+    if (!arg) {
+        return;
+    }
+    struct proto_ctx_ssl *sproto = (struct proto_ctx_ssl *)arg;
+    SSL_set_app_data(sproto->ssl, NULL);
+    free(sproto);
 }
 
 lcb_STATUS lcbio_ssl_apply(lcbio_SOCKET *sock, lcbio_pSSLCTX sctx)
 {
     lcbio_pTABLE old_iot = sock->io, new_iot;
-    lcbio_PROTOCTX *sproto;
+    struct proto_ctx_ssl *sproto;
 
     if (old_iot->model == LCB_IOMODEL_EVENT) {
         new_iot = lcbio_Essl_new(old_iot, sock->u.fd, sctx->ctx);
@@ -440,12 +528,13 @@ lcb_STATUS lcbio_ssl_apply(lcbio_SOCKET *sock, lcbio_pSSLCTX sctx)
 
     if (new_iot) {
         sproto = calloc(1, sizeof(*sproto));
-        sproto->id = LCBIO_PROTOCTX_SSL;
-        sproto->dtor = noop_dtor;
-        lcbio_protoctx_add(sock, sproto);
+        sproto->proto.id = LCBIO_PROTOCTX_SSL;
+        sproto->proto.dtor = noop_dtor;
+        lcbio_protoctx_add(sock, &sproto->proto);
         lcbio_table_unref(old_iot);
         sock->io = new_iot;
         /* just for logging */
+        sproto->ssl = ((lcbio_XSSL *)new_iot)->ssl;
         SSL_set_app_data(((lcbio_XSSL *)new_iot)->ssl, sock);
         return LCB_SUCCESS;
 

package/deps/lcb/src/vbucket/vbucket.c

@@ -932,12 +932,19 @@ char *lcbvb_save_json(lcbvb_CONFIG *cfg)
     cJSON *tmp = NULL, *nodes = NULL;
     cJSON *root = cJSON_CreateObject();
 
-    if (cfg->dtype == LCBVB_DIST_VBUCKET) {
-        tmp = cJSON_CreateString("vbucket");
-    } else {
-        tmp = cJSON_CreateString("ketama");
+    switch (cfg->dtype) {
+        case  LCBVB_DIST_VBUCKET:
+            tmp = cJSON_CreateString("vbucket");
+            break;
+        case LCBVB_DIST_KETAMA:
+            tmp = cJSON_CreateString("ketama");
+            break;
+        default:
+            break;
+    }
+    if (tmp) {
+        cJSON_AddItemToObject(root, "nodeLocator", tmp);
     }
-    cJSON_AddItemToObject(root, "nodeLocator", tmp);
 
     if (cfg->buuid) {
         tmp = cJSON_CreateString(cfg->buuid);
@@ -951,8 +958,10 @@ char *lcbvb_save_json(lcbvb_CONFIG *cfg)
         tmp = cJSON_CreateInt64(cfg->revid);
         cJSON_AddItemToObject(root, "rev", tmp);
     }
-    tmp = cJSON_CreateString(cfg->bname);
-    cJSON_AddItemToObject(root, "name", tmp);
+    if (cfg->bname != NULL) {
+        tmp = cJSON_CreateString(cfg->bname);
+        cJSON_AddItemToObject(root, "name", tmp);
+    }
 
     nodes = cJSON_CreateArray();
     cJSON_AddItemToObject(root, "nodesExt", nodes);

package/deps/lcb/tests/CMakeLists.txt

@@ -173,7 +173,7 @@ MACRO(DEFINE_MOCKTEST plugin test)
             --gtest_filter="ContaminatingUnitTest.*"
             --gtest_throw_on_failure=1
             --gtest_print_time=1
-            --gtest_output=xml:"${PROJECT_BINARY_DIR}/REPORT_${plugin}_${test}.xml")
+            --gtest_output=xml:"${PROJECT_BINARY_DIR}/REPORT_${plugin}_${test}_contaminating.xml")
     SET_TESTS_PROPERTIES(check-contaminating-${plugin}-${test} PROPERTIES LABELS "contaminating" )
 ENDMACRO()
 

package/deps/lcb/tests/iotests/mock-environment.cc

@@ -430,6 +430,9 @@ static void statsCallback(lcb_INSTANCE *instance, lcb_CALLBACK_TYPE, const lcb_R
                     case 1:
                         version = MockEnvironment::VERSION_71;
                         break;
+                    case 2:
+                        version = MockEnvironment::VERSION_72;
+                        break;
                     default:
                         break;
                 }

package/deps/lcb/tests/iotests/mock-environment.h

@@ -248,6 +248,7 @@ class MockEnvironment : public ::testing::Environment
         VERSION_66 = 12,
         VERSION_70 = 13,
         VERSION_71 = 14,
+        VERSION_72 = 15,
     };
 
     void SetUp() override;

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

@@ -89,6 +89,7 @@ TEST_F(RateLimitTest, testRateLimitsKVNumOps)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -131,6 +132,7 @@ TEST_F(RateLimitTest, testRateLimitsKVIngress)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -162,6 +164,7 @@ TEST_F(RateLimitTest, testRateLimitsKVEgress)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -198,6 +201,7 @@ TEST_F(RateLimitTest, testRateLimitsKVMaxConnections)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -438,6 +442,7 @@ TEST_F(RateLimitTest, testRateLimitsKVScopeDataSize)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -478,6 +483,7 @@ TEST_F(RateLimitTest, testRateLimitsQueryNumIndexes)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -527,6 +533,7 @@ TEST_F(RateLimitTest, testRateLimitsSearchNumQueries)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -576,6 +583,7 @@ TEST_F(RateLimitTest, testRateLimitsSearchEgress)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -631,6 +639,7 @@ TEST_F(RateLimitTest, testRateLimitsSearchIngress)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -684,6 +693,7 @@ TEST_F(RateLimitTest, testRateLimitsSearchConcurrentRequests)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_71)
+    SKIP_IF_CLUSTER_VERSION_IS_HIGHER_THAN(MockEnvironment::VERSION_72)
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -726,4 +736,4 @@ TEST_F(RateLimitTest, testRateLimitsSearchConcurrentRequests)
     ASSERT_TRUE(found_error);
 
     drop_user(instance, username);
-}
+}

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);
     }