libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/tests/iotests/mock-environment.h

@@ -71,8 +71,7 @@ class MockCommand
     X(GET_MCPORTS) \
     X(SET_CCCP) \
     X(REGEN_VBCOORDS) \
-    X(RESET_QUERYSTATE) \
-    X(OPFAIL)
+    X(RESET_QUERYSTATE)
 
 public:
     enum Code {

data/ext/libcouchbase/tests/iotests/t_confmon.cc

@@ -7,115 +7,130 @@
 #include <lcbio/iotable.h>
 #include <set>
 
-using namespace lcb::clconfig;
-
-class ConfmonTest : public ::testing::Test
+class Confmon : public ::testing::Test
 {
     void SetUp() {
         MockEnvironment::Reset();
     }
 };
 
-struct evstop_listener : Listener {
+struct evstop_listener {
+    clconfig_listener base;
     lcbio_pTABLE io;
     int called;
-
-    void clconfig_lsn(EventType event, ConfigInfo*) {
-        if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
-            return;
-        }
-        called = 1;
-        IOT_STOP(io);
-    }
-
-    evstop_listener() : Listener(), io(NULL), called(0) {
-    }
 };
 
 extern "C" {
-static void listen_callback1(Listener *lsn, EventType event,
-                             ConfigInfo *info)
+static void listen_callback1(clconfig_listener *lsn, clconfig_event_t event,
+                             clconfig_info *info)
 {
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        return;
+    }
+
+    evstop_listener *me = reinterpret_cast<evstop_listener*>(lsn);
+    me->called = 1;
+    IOT_STOP(me->io);
 }
 }
 
-TEST_F(ConfmonTest, testBasic)
+TEST_F(Confmon, testBasic)
 {
     HandleWrap hw;
     lcb_t instance;
     MockEnvironment::getInstance()->createConnection(hw, instance);
 
 
-    Confmon *mon = new Confmon(instance->settings, instance->iotable);
-    Provider *http = mon->get_provider(CLCONFIG_HTTP);
-    http->enable();
-    http->configure_nodes(*instance->ht_nodes);
+    lcb_confmon *mon = lcb_confmon_create(instance->settings, instance->iotable);
+    clconfig_provider *http = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
+    lcb_clconfig_http_enable(http);
+    lcb_clconfig_http_set_nodes(http, instance->ht_nodes);
 
-    mon->prepare();
+    lcb_confmon_prepare(mon);
 
-    EXPECT_EQ(NULL, mon->get_config());
-    mon->start();
-    mon->start(); // Twice!
-    mon->stop();
-    mon->stop();
+    EXPECT_EQ(NULL, lcb_confmon_get_config(mon));
+    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_start(mon));
+    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_start(mon));
+    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_stop(mon));
+    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_stop(mon));
 
     // Try to find a provider..
-    Provider *provider = mon->get_provider(CLCONFIG_HTTP);
+    clconfig_provider *provider = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
     ASSERT_NE(0, provider->enabled);
 
-    evstop_listener listener;
+    struct evstop_listener listener;
+    memset(&listener, 0, sizeof(listener));
+
+    listener.base.callback = listen_callback1;
+    listener.base.parent = mon;
     listener.io = instance->iotable;
-    mon->add_listener(&listener);
-    mon->start();
+
+    lcb_confmon_add_listener(mon, &listener.base);
+    lcb_confmon_start(mon);
     IOT_START(instance->iotable);
     ASSERT_NE(0, listener.called);
-    delete mon;
+
+    lcb_confmon_destroy(mon);
 }
 
 
-struct listener2 : Listener {
+struct listener2 {
+    clconfig_listener base;
     int call_count;
     lcbio_pTABLE io;
-    Method last_source;
-    std::set<EventType> expected_events;
+    clconfig_method_t last_source;
+    std::set<clconfig_event_t> expected_events;
 
     void reset() {
         call_count = 0;
-        last_source = CLCONFIG_PHONY;
+        last_source = LCB_CLCONFIG_PHONY;
         expected_events.clear();
     }
 
-    listener2() : Listener() {
+    listener2() {
+        memset(&base, 0, sizeof(base));
         io = NULL;
         reset();
     }
+};
 
-    void clconfig_lsn(EventType event, ConfigInfo *info) {
-        if (event == CLCONFIG_EVENT_MONITOR_STOPPED) {
-            IOT_START(io);
-            return;
-        }
+static struct listener2* getListener2(const void *p)
+{
+    return reinterpret_cast<struct listener2*>(const_cast<void*>(p));
+}
 
-        if (!expected_events.empty()) {
-            if (expected_events.end() ==
-                expected_events.find(event)) {
-                return;
-            }
-        }
+extern "C" {
+static void listen_callback2(clconfig_listener *prov,
+                             clconfig_event_t event,
+                             clconfig_info *info)
+{
+    // Increase the number of times we've received a callback..
+    struct listener2* lsn = getListener2(prov);
 
-        call_count++;
-        last_source = info->get_origin();
-        IOT_STOP(io);
+    if (event == CLCONFIG_EVENT_MONITOR_STOPPED) {
+        IOT_START(lsn->io);
+        return;
+    }
 
+    if (!lsn->expected_events.empty()) {
+        if (lsn->expected_events.end() ==
+            lsn->expected_events.find(event)) {
+            return;
+        }
     }
-};
 
-static void runConfmonTest(lcbio_pTABLE io, Confmon *mon)
+    lsn->call_count++;
+    lsn->last_source = info->origin;
+    IOT_STOP(lsn->io);
+}
+}
+
+static void runConfmon(lcbio_pTABLE io, lcb_confmon *mon)
 {
     IOT_START(io);
 }
 
-TEST_F(ConfmonTest, testCycle)
+TEST_F(Confmon, testCycle)
 {
     HandleWrap hw;
     lcb_t instance;
@@ -130,54 +145,57 @@ TEST_F(ConfmonTest, testCycle)
     instance->settings->bc_http_stream_time = 100000;
     instance->memd_sockpool->tmoidle = 100000;
 
-    Confmon *mon = new Confmon(instance->settings, instance->iotable);
+    lcb_confmon *mon = lcb_confmon_create(instance->settings, instance->iotable);
 
     struct listener2 lsn;
+    lsn.base.callback = listen_callback2;
     lsn.io = instance->iotable;
     lsn.reset();
-    mon->add_listener(&lsn);
+
+    lcb_confmon_add_listener(mon, &lsn.base);
 
     mock->makeConnectParams(cropts, NULL);
-    Provider *cccp = mon->get_provider(CLCONFIG_CCCP);
-    Provider *http = mon->get_provider(CLCONFIG_HTTP);
+    clconfig_provider *cccp = lcb_confmon_get_provider(mon, LCB_CLCONFIG_CCCP);
+    clconfig_provider *http = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
 
-    lcb::Hostlist hl;
-    hl.add(cropts.v.v2.mchosts, 11210);
-    cccp->enable(instance);
-    cccp->configure_nodes(hl);
+    hostlist_t hl = hostlist_create();
+    hostlist_add_stringz(hl, cropts.v.v2.mchosts, 11210);
+    lcb_clconfig_cccp_enable(cccp, instance);
+    lcb_clconfig_cccp_set_nodes(cccp, hl);
 
-    http->enable();
-    http->configure_nodes(*instance->ht_nodes);
+    lcb_clconfig_http_enable(http);
+    lcb_clconfig_http_set_nodes(http, instance->ht_nodes);
+    hostlist_destroy(hl);
 
-    mon->prepare();
-    mon->start();
+    lcb_confmon_prepare(mon);
+    lcb_confmon_start(mon);
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
-    runConfmonTest(lsn.io, mon);
+    runConfmon(lsn.io, mon);
 
     // Ensure CCCP is functioning properly and we're called only once.
     ASSERT_EQ(1, lsn.call_count);
-    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
+    ASSERT_EQ(LCB_CLCONFIG_CCCP, lsn.last_source);
 
-    mon->start();
+    lcb_confmon_start(mon);
     lsn.reset();
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
-    runConfmonTest(lsn.io, mon);
+    runConfmon(lsn.io, mon);
     ASSERT_EQ(1, lsn.call_count);
-    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
+    ASSERT_EQ(LCB_CLCONFIG_CCCP, lsn.last_source);
 
     mock->setCCCP(false);
     mock->failoverNode(5);
     lsn.reset();
-    mon->start();
+    lcb_confmon_start(mon);
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
-    runConfmonTest(lsn.io, mon);
-    ASSERT_EQ(CLCONFIG_HTTP, lsn.last_source);
+    runConfmon(lsn.io, mon);
+    ASSERT_EQ(LCB_CLCONFIG_HTTP, lsn.last_source);
     ASSERT_EQ(1, lsn.call_count);
-    delete mon;
+    lcb_confmon_destroy(mon);
 }
 
-TEST_F(ConfmonTest, testBootstrapMethods)
+TEST_F(Confmon, testBootstrapMethods)
 {
     lcb_t instance;
     HandleWrap hw;
@@ -186,38 +204,38 @@ TEST_F(ConfmonTest, testBootstrapMethods)
     ASSERT_EQ(LCB_SUCCESS, err);
 
     // Try the various bootstrap times
-    lcb::Bootstrap* bs = instance->bs_state;
-    hrtime_t last = bs->get_last_refresh(), cur = 0;
+    struct lcb_BOOTSTRAP *bs = instance->bootstrap;
+    hrtime_t last = bs->last_refresh, cur = 0;
 
     // Reset it for the time being
-    bs->reset_last_refresh();
-    instance->confmon->stop();
+    bs->last_refresh = 0;
+    lcb_confmon_stop(instance->confmon);
 
     // Refreshing now should work
-    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
-    ASSERT_TRUE(instance->confmon->is_refreshing());
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
+    ASSERT_NE(0, lcb_confmon_is_refreshing(instance->confmon));
 
-    cur = bs->get_last_refresh();
+    cur = bs->last_refresh;
     ASSERT_GT(cur, 0);
-    ASSERT_EQ(0, bs->get_errcounter());
+    ASSERT_EQ(0, bs->errcounter);
     last = cur;
 
     // Stop it, so the state is reset
-    instance->confmon->stop();
-    ASSERT_FALSE(instance->confmon->is_refreshing());
+    lcb_confmon_stop(instance->confmon);
+    ASSERT_EQ(0, lcb_confmon_is_refreshing(instance->confmon));
 
-    instance->bootstrap(lcb::BS_REFRESH_THROTTLE|lcb::BS_REFRESH_INCRERR);
-    ASSERT_EQ(last, bs->get_last_refresh());
-    ASSERT_EQ(1, bs->get_errcounter());
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE|LCB_BS_REFRESH_INCRERR);
+    ASSERT_EQ(last, bs->last_refresh);
+    ASSERT_EQ(1, bs->errcounter);
 
     // Ensure that a throttled-without-incr doesn't actually incr
-    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
-    ASSERT_EQ(1, bs->get_errcounter());
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
+    ASSERT_EQ(1, bs->errcounter);
 
     // No refresh yet
-    ASSERT_FALSE(instance->confmon->is_refreshing());
+    ASSERT_EQ(0, lcb_confmon_is_refreshing(instance->confmon));
 
-    instance->bootstrap(lcb::BS_REFRESH_ALWAYS);
-    ASSERT_TRUE(instance->confmon->is_refreshing());
-    instance->confmon->stop();
+    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+    ASSERT_NE(0, lcb_confmon_is_refreshing(instance->confmon));
+    lcb_confmon_stop(instance->confmon);
 }

data/ext/libcouchbase/tests/mc/t_alloc.cc

@@ -223,16 +223,15 @@ TEST_F(McAlloc, testValueAlloc)
     mcreq_release_packet(pipeline, packet);
 }
 
-struct ExtraCookie : mc_REQDATAEX {
+struct ExtraCookie {
+    mc_REQDATAEX base;
     int remaining;
-    ExtraCookie(const mc_REQDATAPROCS& procs_)
-        : mc_REQDATAEX(NULL, procs_, 0), remaining(0) {
-    }
 };
 
 extern "C" {
 static void pkt_dtor(mc_PACKET *pkt) {
-    ExtraCookie *ec = static_cast<ExtraCookie*>(pkt->u_rdata.exdata);
+    mc_REQDATAEX *rd = pkt->u_rdata.exdata;
+    ExtraCookie *ec = (ExtraCookie *)rd;
     ec->remaining--;
 }
 }
@@ -241,17 +240,18 @@ TEST_F(McAlloc, testRdataExDtor)
 {
     CQWrap q;
     lcb_CMDBASE basecmd;
-    const static mc_REQDATAPROCS procs = { NULL, pkt_dtor };
+    ExtraCookie ec;
     protocol_binary_request_header hdr;
 
     memset(&hdr, 0, sizeof hdr);
     memset(&basecmd, 0, sizeof basecmd);
+    memset(&ec, 0, sizeof ec);
 
+    mc_REQDATAPROCS procs = { NULL, pkt_dtor };
+    ec.base.procs = &procs;
     basecmd.key.contig.bytes = "foo";
     basecmd.key.contig.nbytes = 3;
 
-    ExtraCookie ec(procs);
-
     mcreq_sched_enter(&q);
     for (unsigned ii = 0; ii < 5; ii++) {
         lcb_error_t err;
@@ -260,7 +260,7 @@ TEST_F(McAlloc, testRdataExDtor)
         err = mcreq_basic_packet(&q, &basecmd, &hdr, 0, &pkt, &pl, 0);
         ASSERT_EQ(LCB_SUCCESS, err);
         pkt->flags |= MCREQ_F_REQEXT;
-        pkt->u_rdata.exdata = &ec;
+        pkt->u_rdata.exdata = &ec.base;
         mcreq_sched_add(pl, pkt);
         ec.remaining++;
     }

data/ext/libcouchbase/tools/cbc-pillowfight.cc

@@ -630,7 +630,7 @@ private:
 
         const lcb_U64 elapsed_ns = now - previous_time;
         const lcb_U64 wanted_duration_ns =
-                (config.opsPerCycle * 1e9) / (config.getRateLimit() * config.getNumThreads());
+                config.opsPerCycle * 1e9 / config.getRateLimit();
         // On first invocation no previous_time, so skip attempting to sleep.
         if (elapsed_ns > 0 && elapsed_ns < wanted_duration_ns) {
             // Dampen the sleep time by averaging with the previous

data/lib/libcouchbase/ext/tasks.rb

@@ -74,14 +74,18 @@ else
     end
 
     file 'ext/libcouchbase/build/makefile' => 'ext/libcouchbase/build' do
+        result = nil
         Dir.chdir("ext/libcouchbase") do |path|
-            system './cmake/configure', '-with-libuv', ::File.expand_path('../../', ::Libuv::Ext.path_to_internal_libuv)
+            result = system './cmake/configure', '-with-libuv', ::File.expand_path('../../', ::Libuv::Ext.path_to_internal_libuv)
         end
+        raise 'could not find cmake on path' unless result
     end
 
     file "ext/libcouchbase/build/lib/libcouchbase_libuv.#{FFI::Platform::LIBSUFFIX}" => 'ext/libcouchbase/build/makefile' do
+        result = nil
         Dir.chdir('ext/libcouchbase/build') do |path|
-            system 'make'
+            result = system 'make'
         end
+        raise 'make failed' unless result
     end
 end

data/lib/libcouchbase/query_view.rb

@@ -95,7 +95,7 @@ module Libcouchbase
             # check for included document here
             if @include_docs && row[:docresp]
                 doc = row[:docresp]
-                raw_string = doc[:value].read_string(doc[:nvalue])
+                raw_string = doc[:value].null? ? '' : doc[:value].read_string(doc[:nvalue])
                 resp.value, meta[:format] = @connection.parse_document(raw_string, flags: doc[:itmflags])
                 meta[:flags] = doc[:itmflags]
             end

data/lib/libcouchbase/results_fiber.rb

@@ -37,8 +37,8 @@ module Libcouchbase
                 @fiber = Fiber.current
 
                 begin
-                    while not @query_completed do
-                        if @results.length > 0
+                    while !@query_completed || (cont = @results.length > 0) do
+                        if cont
                             @resume_results = false
                             yield @results.shift
                         else
@@ -76,8 +76,8 @@ module Libcouchbase
                 @fiber = Fiber.current
 
                 begin
-                    while not @query_completed do
-                        if index < @results.length
+                    while !@query_completed || (cont = index < @results.length) do
+                        if cont
                             @resume_results = false
                             yield @results[index]
                             index += 1
@@ -132,8 +132,8 @@ module Libcouchbase
 
                 result = []
                 begin
-                    while not @query_completed do
-                        if index < @results.length && index < num
+                    while !@query_completed  || (cont = index < @results.length && index < num) do
+                        if cont
                             result << @results[index]
                             index += 1
                         else