libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/mcserver/negotiate.h

@@ -38,7 +38,7 @@
 struct lcb_settings_st;
 
 namespace lcb {
-class SessionRequest {
+class SessionRequest : public lcb::io::ConnectionRequest {
 public:
     /**
      * @brief Start negotiation on a connected socket
@@ -82,8 +82,6 @@ public:
 };
 class SessionRequestImpl;
 
-extern "C" { void sessreq_cancel(SessionRequest *); }
-
 class SessionInfo : public lcbio_PROTOCTX {
 public:
     /**

data/ext/libcouchbase/src/mctx-helper.h

@@ -0,0 +1,51 @@
+/*
+ *     Copyright 2016 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#ifndef LCB_MCTX_HELPER_H
+#define LCB_MCTX_HELPER_H
+#include <libcouchbase/couchbase.h>
+
+namespace lcb {
+
+class MultiCmdContext : public lcb_MULTICMD_CTX {
+protected:
+    virtual lcb_error_t MCTX_addcmd(const lcb_CMDBASE* cmd) = 0;
+    virtual lcb_error_t MCTX_done(const void *cookie) = 0;
+    virtual void MCTX_fail() = 0;
+
+    MultiCmdContext() {
+        lcb_MULTICMD_CTX::addcmd = dispatch_mctx_addcmd;
+        lcb_MULTICMD_CTX::done = dispatch_mctx_done;
+        lcb_MULTICMD_CTX::fail = dispatch_mctx_fail;
+    }
+
+    virtual ~MultiCmdContext() {}
+
+private:
+    static lcb_error_t dispatch_mctx_addcmd(lcb_MULTICMD_CTX* ctx, const lcb_CMDBASE * cmd) {
+        return static_cast<MultiCmdContext*>(ctx)->MCTX_addcmd(cmd);
+    }
+    static lcb_error_t dispatch_mctx_done(lcb_MULTICMD_CTX* ctx, const void *cookie) {
+        return static_cast<MultiCmdContext*>(ctx)->MCTX_done(cookie);
+    }
+    static void dispatch_mctx_fail(lcb_MULTICMD_CTX* ctx) {
+        static_cast<MultiCmdContext*>(ctx)->MCTX_fail();
+    }
+};
+
+}
+
+#endif

data/ext/libcouchbase/src/n1ql/ixmgmt.cc

@@ -210,8 +210,7 @@ dispatch_common(lcb_t instance,
 // mind-numbing buffer copies. Maybe this can be done via a macro instead?
 class IndexSpec : public lcb_N1XSPEC {
 public:
-    IndexSpec(const char *s, size_t n) {
-        memset(static_cast<lcb_N1XSPEC*>(this), 0, sizeof (lcb_N1XSPEC));
+    IndexSpec(const char *s, size_t n) : lcb_N1XSPEC() {
         load_json(s, n);
     }
     inline IndexSpec(const lcb_N1XSPEC *spec);

data/ext/libcouchbase/src/n1ql/n1ql.cc

@@ -142,10 +142,10 @@ struct lcb_N1QLCACHE_st {
     }
 };
 
-typedef struct lcb_N1QLREQ {
+typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     const lcb_RESPHTTP *cur_htresp;
     struct lcb_http_request_st *htreq;
-    lcbjsp_PARSER *parser;
+    lcb::jsparse::Parser *parser;
     const void *cookie;
     lcb_N1QLCALLBACK callback;
     lcb_t instance;
@@ -155,6 +155,9 @@ typedef struct lcb_N1QLREQ {
     // How many rows were received. Used to avoid parsing the meta
     size_t nrows;
 
+    // Host for CBAS/Analytics query
+    std::string cbashost;
+
     /** The PREPARE query itself */
     struct lcb_N1QLREQ *prepare_req;
 
@@ -227,9 +230,28 @@ typedef struct lcb_N1QLREQ {
      */
     inline void fail_prepared(const lcb_RESPN1QL *orig, lcb_error_t err);
 
+    bool is_cbas() const {
+        return !cbashost.empty();
+    }
+
     inline lcb_N1QLREQ(lcb_t obj, const void *user_cookie, const lcb_CMDN1QL *cmd);
     inline ~lcb_N1QLREQ();
 
+    // Parser overrides:
+    void JSPARSE_on_row(const lcb::jsparse::Row& row) {
+        lcb_RESPN1QL resp = { 0 };
+        resp.row = static_cast<const char *>(row.row.iov_base);
+        resp.nrow = row.row.iov_len;
+        nrows++;
+        invoke_row(&resp, false);
+    }
+    void JSPARSE_on_error(const std::string&) {
+        lasterr = LCB_PROTOCOL_ERROR;
+    }
+    void JSPARSE_on_complete(const std::string&) {
+        // Nothing
+    }
+
 } N1QLREQ;
 
 static bool
@@ -269,8 +291,12 @@ lcb_n1qlcache_getplan(lcb_N1QLCACHE *cache,
     }
 }
 
-#define WTF_MAGIC_STRING \
-    "index deleted or node hosting the index is down - cause: queryport.indexNotFound"
+
+static const char *wtf_magic_strings[] = {
+        "index deleted or node hosting the index is down - cause: queryport.indexNotFound",
+        "Index Not Found - cause: queryport.indexNotFound",
+        NULL
+};
 
 static bool
 has_retriable_error(const Json::Value& root)
@@ -296,8 +322,13 @@ has_retriable_error(const Json::Value& root)
                 return true;
             }
         }
-        if (jmsg.isString() && strstr(jmsg.asCString(), WTF_MAGIC_STRING) != NULL) {
-            return true;
+        if (jmsg.isString()) {
+            const char *jmstr = jmsg.asCString();
+            for (const char **curs = wtf_magic_strings; *curs; curs++) {
+                if (!strstr(jmstr, *curs)) {
+                    return true;
+                }
+            }
         }
     }
     return false;
@@ -330,8 +361,7 @@ N1QLREQ::maybe_retry()
     }
 
     was_retried = true;
-
-    lcbjsp_get_postmortem(parser, &meta);
+    parser->get_postmortem(meta);
     if (!parse_json(static_cast<const char*>(meta.iov_base), meta.iov_len, root)) {
         return false; // Not JSON
     }
@@ -344,16 +374,15 @@ N1QLREQ::maybe_retry()
     // Let's see if we can actually retry. First remove the existing prepared
     // entry:
     cache().remove_entry(statement);
-    lcb_error_t rc = request_plan();
-    if (rc != LCB_SUCCESS) {
-        lasterr = rc;
-        return false;
 
-    } else {
+    if ((lasterr = request_plan()) == LCB_SUCCESS) {
         // We'll be parsing more rows later on..
-        lcbjsp_reset(parser);
+        delete parser;
+        parser = new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_N1QL, this);
+        return true;
     }
-    return true;
+
+    return false;
 }
 
 void
@@ -366,7 +395,7 @@ N1QLREQ::invoke_row(lcb_RESPN1QL *resp, bool is_last)
         lcb_IOV meta;
         resp->rflags |= LCB_RESP_F_FINAL;
         resp->rc = lasterr;
-        lcbjsp_get_postmortem(parser, &meta);
+        parser->get_postmortem(meta);
         resp->row = static_cast<const char*>(meta.iov_base);
         resp->nrow = meta.iov_len;
     }
@@ -392,31 +421,13 @@ lcb_N1QLREQ::~lcb_N1QLREQ()
     }
 
     if (parser) {
-        lcbjsp_free(parser);
+        delete parser;
     }
     if (prepare_req) {
         lcb_n1ql_cancel(instance, prepare_req);
     }
 }
 
-static void
-row_callback(lcbjsp_PARSER *parser, const lcbjsp_ROW *datum)
-{
-    N1QLREQ *req = static_cast<N1QLREQ*>(parser->data);
-    lcb_RESPN1QL resp = { 0 };
-
-    if (datum->type == LCBJSP_TYPE_ROW) {
-        resp.row = static_cast<const char*>(datum->row.iov_base);
-        resp.nrow = datum->row.iov_len;
-        req->nrows++;
-        req->invoke_row(&resp, 0);
-    } else if (datum->type == LCBJSP_TYPE_ERROR) {
-        req->lasterr = resp.rc = LCB_PROTOCOL_ERROR;
-    } else if (datum->type == LCBJSP_TYPE_COMPLETE) {
-        /* Nothing */
-    }
-}
-
 static void
 chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
 {
@@ -444,8 +455,7 @@ chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
         delete req;
         return;
     }
-
-    lcbjsp_feed(req->parser, static_cast<const char*>(rh->body), rh->nbody);
+    req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
 }
 
 #define QUERY_PATH "/query/service"
@@ -512,7 +522,14 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     htcmd.content_type = "application/json";
     htcmd.method = LCB_HTTP_METHOD_POST;
-    htcmd.type = LCB_HTTP_TYPE_N1QL;
+
+    if (is_cbas()) {
+        htcmd.type = LCB_HTTP_TYPE_RAW;
+        htcmd.host = cbashost.c_str();
+    } else {
+        htcmd.type = LCB_HTTP_TYPE_N1QL;
+    }
+
     htcmd.cmdflags = LCB_CMDHTTP_F_STREAM|LCB_CMDHTTP_F_CASTMO;
     if (flags & F_CMDN1QL_CREDSAUTH) {
         htcmd.cmdflags |= LCB_CMDHTTP_F_NOUPASS;
@@ -522,7 +539,7 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     lcb_error_t rc = lcb_http3(instance, this, &htcmd);
     if (rc == LCB_SUCCESS) {
-        lcb_htreq_setcb(htreq, chunk_callback);
+        htreq->set_callback(chunk_callback);
     }
     return rc;
 }
@@ -586,13 +603,12 @@ lcb_n1qlreq_parsetmo(const std::string& s)
 
 lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
     const void *user_cookie, const lcb_CMDN1QL *cmd)
-    : cur_htresp(NULL), htreq(NULL), parser(lcbjsp_create(LCBJSP_MODE_N1QL)),
+    : cur_htresp(NULL), htreq(NULL),
+      parser(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_N1QL, this)),
       cookie(user_cookie), callback(cmd->callback), instance(obj),
       lasterr(LCB_SUCCESS), flags(cmd->cmdflags), timeout(0),
       nrows(0), prepare_req(NULL), was_retried(false)
 {
-    parser->data = this;
-    parser->callback = row_callback;
     if (cmd->handle) {
         *cmd->handle = this;
     }
@@ -604,6 +620,22 @@ lcb_N1QLREQ::lcb_N1QLREQ(lcb_t obj,
         return;
     }
 
+    if (flags & LCB_CMDN1QL_F_CBASQUERY) {
+        if (!cmd->host) {
+            lasterr = LCB_EINVAL;
+            return;
+        }
+        cbashost.assign(cmd->host);
+        if (cbashost.empty()) {
+            lasterr = LCB_EINVAL;
+            return;
+        }
+        if (flags & LCB_CMDN1QL_F_PREPCACHE) {
+            lasterr = LCB_OPTIONS_CONFLICT;
+            return;
+        }
+    }
+
     const Json::Value& j_statement = json_const()["statement"];
     if (j_statement.isString()) {
         statement = j_statement.asString();

data/ext/libcouchbase/src/netbuf/netbuf.c

@@ -405,7 +405,7 @@ mblock_release_ptr(nb_MBPOOL *pool, char * ptr, nb_SIZE size)
         return;
     }
 
-    fprintf(stderr, "NETBUF: Requested to release pointer %p which was not allocated\n", ptr);
+    fprintf(stderr, "NETBUF: Requested to release pointer %p which was not allocated\n", (void *)ptr);
     assert(0);
 }
 
@@ -785,7 +785,7 @@ dump_managed_block(nb_MBLOCK *block, FILE *fp)
 {
     const char *indent = "  ";
     fprintf(fp, "%sBLOCK(MANAGED)=%p; BUF=%p, %uB\n", indent,
-        (void *)block, block->root, block->nalloc);
+        (void *)block, (void *)block->root, block->nalloc);
     indent = "     ";
 
     fprintf(fp, "%sUSAGE:\n", indent);
@@ -828,7 +828,7 @@ dump_sendq(nb_SENDQ *q, FILE *fp)
     fprintf(fp, "Send Queue\n");
     SLLIST_FOREACH(&q->pending, ll) {
         nb_SNDQELEM *e = SLLIST_ITEM(ll, nb_SNDQELEM, slnode);
-        fprintf(fp, "%s[Base=%p, Len=%u]\n", indent, e->base, e->len);
+        fprintf(fp, "%s[Base=%p, Len=%u]\n", indent, (void *)e->base, e->len);
         if (q->last_requested == e) {
             fprintf(fp, "%s<Current Flush Limit @%u^^^>\n", indent, q->last_offset);
         }
@@ -851,7 +851,7 @@ netbuf_dump_status(nb_MGR *mgr, FILE *fp)
         nb_MBLOCK *block = SLLIST_ITEM(ll, nb_MBLOCK, slnode);
         const char *indent = "    ";
         fprintf(fp, "%sBLOCK(AVAIL)=%p; BUF=%p, %uB\n", indent,
-            (void*)block, block->root, block->nalloc);
+            (void*)block, (void *)block->root, block->nalloc);
     }
     dump_sendq(&mgr->sendq, fp);
 }

data/ext/libcouchbase/src/newconfig.cc

@@ -221,7 +221,7 @@ iterwipe_cb(mc_CMDQUEUE *cq, mc_PIPELINE *oldpl, mc_PACKET *oldpkt, void *)
         return MCREQ_KEEP_PACKET;
     }
 
-    lcb_log(LOGARGS((lcb_t)cq->cqdata, DEBUG), "Remapped packet %p (SEQ=%u) from "SERVER_FMT " to " SERVER_FMT,
+    lcb_log(LOGARGS((lcb_t)cq->cqdata, DEBUG), "Remapped packet %p (SEQ=%u) from " SERVER_FMT " to " SERVER_FMT,
         (void*)oldpkt, oldpkt->opaque, SERVER_ARGS((lcb::Server*)oldpl), SERVER_ARGS((lcb::Server*)newpl));
 
     /** Otherwise, copy over the packet and find the new vBucket to map to */
@@ -256,7 +256,7 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
             cur->set_new_index(newix);
             ppnew[newix] = cur;
             ppold[ii] = NULL;
-            lcb_log(LOGARGS(instance, INFO), "Reusing server "SERVER_FMT". OldIndex=%d. NewIndex=%d", SERVER_ARGS(cur), ii, newix);
+            lcb_log(LOGARGS(instance, INFO), "Reusing server " SERVER_FMT ". OldIndex=%d. NewIndex=%d", SERVER_ARGS(cur), ii, newix);
         }
     }
 
@@ -305,14 +305,14 @@ replace_config(lcb_t instance, lcbvb_CONFIG *oldconfig, lcbvb_CONFIG *newconfig)
     free(ppold);
 }
 
-void lcb_update_vbconfig(lcb_t instance, clconfig_info *config)
+void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config)
 {
     lcb_configuration_t change_status;
-    clconfig_info *old_config = instance->cur_configinfo;
+    lcb::clconfig::ConfigInfo *old_config = instance->cur_configinfo;
     mc_CMDQUEUE *q = &instance->cmdq;
 
     instance->cur_configinfo = config;
-    lcb_clconfig_incref(config);
+    config->incref();
     q->config = instance->cur_configinfo->vbc;
     q->cqdata = instance;
 
@@ -328,7 +328,7 @@ void lcb_update_vbconfig(lcb_t instance, clconfig_info *config)
         lcb_vbguess_newconfig(instance, config->vbc, instance->vbguess);
 
         replace_config(instance, old_config->vbc, config->vbc);
-        lcb_clconfig_decref(old_config);
+        old_config->decref();
         change_status = LCB_CONFIGURATION_CHANGED;
     } else {
         size_t nservers = VB_NSERVERS(config->vbc);

data/ext/libcouchbase/src/nodeinfo.cc

@@ -70,7 +70,7 @@ lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned ix)
 
     if (type & LCB_NODE_HTCONFIG) {
         if (type & LCB_NODE_CONNECTED) {
-            const lcb_host_t *host = lcb_confmon_get_rest_host(instance->confmon);
+            const lcb_host_t *host = lcb::clconfig::http_get_host(instance->confmon);
             if (host) {
                 return mk_scratch_host(instance, host);
             } else {
@@ -167,7 +167,7 @@ lcb_int32_t lcb_get_num_nodes(lcb_t instance)
 LIBCOUCHBASE_API
 const char *const *lcb_get_server_list(lcb_t instance)
 {
-    return hostlist_strents(instance->ht_nodes);
+    return instance->ht_nodes->get_strlist();
 }
 
 LIBCOUCHBASE_API

data/ext/libcouchbase/src/operations/{cbflush.c → cbflush.cc}

@@ -15,11 +15,10 @@
  */
 
 #include "internal.h"
-#include "simplestring.h"
 #include <http/http.h>
 
 static void
-flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+flush_cb(lcb_t instance, int, const lcb_RESPBASE *rb)
 {
     const lcb_RESPHTTP *resp = (const lcb_RESPHTTP *)rb;
     lcb_RESPCBFLUSH fresp = { 0 };
@@ -35,37 +34,30 @@ flush_cb(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
     if (callback) {
         callback(instance, LCB_CALLBACK_CBFLUSH, (lcb_RESPBASE*)&fresp);
     }
-    (void)cbtype;
 }
 
 LIBCOUCHBASE_API
 lcb_error_t
-lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDBASE *cmd)
+lcb_cbflush3(lcb_t instance, const void *cookie, const lcb_CMDBASE *)
 {
     lcb_http_request_t htr;
     lcb_CMDHTTP htcmd = { 0 };
-    lcb_string urlpath;
     lcb_error_t rc;
 
-    (void)cmd;
-
-    lcb_string_init(&urlpath);
-    lcb_string_appendz(&urlpath, "/pools/default/buckets/");
-    lcb_string_appendz(&urlpath, LCBT_SETTING(instance, bucket));
-    lcb_string_appendz(&urlpath, "/controller/doFlush");
-
+    std::string urlpath("/pools/default/buckets/");
+    urlpath.append(LCBT_SETTING(instance, bucket));
+    urlpath.append("/controller/doFlush");
 
     htcmd.type = LCB_HTTP_TYPE_MANAGEMENT;
     htcmd.method = LCB_HTTP_METHOD_POST;
     htcmd.reqhandle = &htr;
-    LCB_CMD_SET_KEY(&htcmd, urlpath.base, urlpath.nused);
+    LCB_CMD_SET_KEY(&htcmd, urlpath.c_str(), urlpath.size());
 
     rc = lcb_http3(instance, cookie, &htcmd);
-    lcb_string_release(&urlpath);
 
     if (rc != LCB_SUCCESS) {
         return rc;
     }
-    lcb_htreq_setcb(htr, flush_cb);
+    htr->set_callback(flush_cb);
     return LCB_SUCCESS;
 }