libcouchbase 0.2.0 → 0.3.1

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

@@ -24,6 +24,9 @@
 #include <netbuf/netbuf.h>
 
 #ifdef __cplusplus
+struct lcb_settings_st;
+struct lcb_server_st;
+
 namespace lcb {
 
 class RetryQueue;
@@ -106,10 +109,6 @@ public:
         return mutation_tokens;
     }
 
-    bool supports_compression() const {
-        return compsupport;
-    }
-
     bool is_connected() const {
         return connctx != NULL;
     }
@@ -173,12 +172,10 @@ public:
 
     enum ReadState {
         PKT_READ_COMPLETE,
-        PKT_READ_PARTIAL,
-        PKT_READ_ABORT
+        PKT_READ_PARTIAL
     };
 
     ReadState try_read(lcbio_CTX *ctx, rdb_IOROPE *ior);
-    bool handle_unknown_error(const MemcachedResponse& resinfo, lcb_error_t& newerr);
     bool handle_nmv(MemcachedResponse& resinfo, mc_PACKET *oldpkt);
     bool maybe_retry_packet(mc_PACKET *pkt, lcb_error_t err);
     bool maybe_reconnect_on_fake_timeout(lcb_error_t received_error);
@@ -209,5 +206,13 @@ public:
     lcb_host_t *curhost;
 };
 }
+
+typedef lcb::Server mc_SERVER;
+extern "C" {int mcserver_supports_compression(mc_SERVER*);}
+
+#else
+/* C only */
+typedef struct mc_SERVER mc_SERVER;
+int mcserver_supports_compression(mc_SERVER *server);
 #endif /* __cplusplus */
 #endif /* LCB_MCSERVER_H */

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

@@ -16,10 +16,6 @@
  */
 
 #include <algorithm>
-#include <string>
-#include <sstream>
-#include <vector>
-
 #include "packetutils.h"
 #include "mcserver.h"
 #include "logging.h"
@@ -30,7 +26,6 @@
 #include <cbsasl/cbsasl.h>
 #include "negotiate.h"
 #include "ctx-log-inl.h"
-#include "auth-priv.h"
 
 using namespace lcb;
 
@@ -39,7 +34,6 @@ static void cleanup_negotiated(SessionInfo* info);
 static void handle_ioerr(lcbio_CTX *ctx, lcb_error_t err);
 #define SESSREQ_LOGFMT "<%s:%s> (SASLREQ=%p) "
 
-
 static void timeout_handler(void *arg);
 
 #define SESSREQ_LOGID(s) get_ctx_host(s->ctx), get_ctx_port(s->ctx), (void*)s
@@ -71,12 +65,9 @@ public:
     bool read_hello(const lcb::MemcachedResponse& packet);
     void send_auth(const char *sasl_data, unsigned ndata);
     void handle_read(lcbio_CTX *ioctx);
-    bool maybe_select_bucket();
 
     enum MechStatus { MECH_UNAVAILABLE, MECH_NOT_NEEDED, MECH_OK };
     MechStatus set_chosen_mech(std::string& mechlist, const char **data, unsigned int *ndata);
-    bool request_errmap();
-    bool update_errmap(const lcb::MemcachedResponse& packet);
 
     SessionRequestImpl(lcbio_CONNDONE_cb callback, void *data, uint32_t timeout, lcbio_TABLE *iot, lcb_settings* settings_)
         : ctx(NULL), cb(callback), cbdata(data),
@@ -332,11 +323,6 @@ SessionRequestImpl::send_hello()
 
     unsigned nfeatures = 0;
     features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TLS;
-    features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XATTR;
-    features[nfeatures++] = PROTOCOL_BINARY_FEATURE_SELECT_BUCKET;
-    if (settings->use_errmap) {
-        features[nfeatures++] = PROTOCOL_BINARY_FEATURE_XERROR;
-    }
     if (settings->tcp_nodelay) {
         features[nfeatures++] = PROTOCOL_BINARY_FEATURE_TCPNODELAY;
     }
@@ -373,7 +359,6 @@ SessionRequestImpl::send_hello()
         lcb_U16 tmp = htons(features[ii]);
         lcbio_ctx_put(ctx, &tmp, sizeof tmp);
     }
-
     lcbio_ctx_rwant(ctx, 24);
     return true;
 }
@@ -389,74 +374,18 @@ SessionRequestImpl::read_hello(const lcb::MemcachedResponse& resp)
         lcb_U16 tmp;
         memcpy(&tmp, cur, sizeof(tmp));
         tmp = ntohs(tmp);
-        lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server supports feature: 0x%x (%s)", SESSREQ_LOGID(this), tmp, protocol_feature_2_text(tmp));
+        lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Found feature 0x%x (%s)", SESSREQ_LOGID(this), tmp, protocol_feature_2_text(tmp));
         info->server_features.push_back(tmp);
     }
     return true;
 }
 
-bool
-SessionRequestImpl::request_errmap() {
-    lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_GET_ERROR_MAP);
-    uint16_t version = htons(1);
-    hdr.sizes(0, 0, 2);
-    const char *p = reinterpret_cast<const char *>(&version);
-
-    lcbio_ctx_put(ctx, hdr.data(), hdr.size());
-    lcbio_ctx_put(ctx, p, 2);
-    lcbio_ctx_rwant(ctx, 24);
-    return true;
-}
-
-bool
-SessionRequestImpl::update_errmap(const lcb::MemcachedResponse& resp)
-{
-    // Get the error map object
-    using lcb::errmap::ErrorMap;
-
-    std::string errmsg;
-    ErrorMap& mm = *settings->errmap;
-    ErrorMap::ParseStatus status = mm.parse(
-        resp.body<const char*>(), resp.bodylen(), errmsg);
-
-    if (status != ErrorMap::UPDATED && status != ErrorMap::NOT_UPDATED) {
-        errmsg = "Couldn't update error map: " + errmsg;
-        set_error(LCB_PROTOCOL_ERROR, errmsg.c_str());
-        return false;
-    }
-
-    return true;
-}
-
-// Returns true if sending the SELECT_BUCKET command, false otherwise.
-bool
-SessionRequestImpl::maybe_select_bucket() {
-
-    // Only send a SELECT_BUCKET if we have the SELECT_BUCKET bit enabled.
-    if (!info->has_feature(PROTOCOL_BINARY_FEATURE_SELECT_BUCKET)) {
-        return false;
-    }
-
-    if (!settings->select_bucket) {
-        lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SELECT_BUCKET Disabled by application", SESSREQ_LOGID(this));
-        return false;
-    }
-
-    // send the SELECT_BUCKET command:
-    lcb_log(LOGARGS(this, INFO), SESSREQ_LOGFMT "Sending SELECT_BUCKET", SESSREQ_LOGID(this));
-    lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_SELECT_BUCKET);
-    req.sizes(0, strlen(settings->bucket), 0);
-    lcbio_ctx_put(ctx, req.data(), req.size());
-    lcbio_ctx_put(ctx, settings->bucket, strlen(settings->bucket));
-    LCBIO_CTX_RSCHEDULE(ctx, 24);
-    return true;
-}
-
-static bool isUnsupported(uint16_t status) {
-    return status == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED ||
-            status == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND ||
-            status == PROTOCOL_BINARY_RESPONSE_EACCESS;
-}
+typedef enum {
+    SREQ_S_WAIT,
+    SREQ_S_AUTHDONE,
+    SREQ_S_HELLODONE,
+    SREQ_S_ERROR
+} sreq_STATE;
 
 /**
  * It's assumed the server buffers will be reset upon close(), so we must make
@@ -467,7 +396,7 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
 {
     lcb::MemcachedResponse resp;
     unsigned required;
-    bool completed = false;
+    sreq_STATE state = SREQ_S_WAIT;
 
     GT_NEXT_PACKET:
 
@@ -486,92 +415,66 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
         MechStatus mechrc = set_chosen_mech(mechs, &mechlist_data, &nmechlist_data);
         if (mechrc == MECH_OK) {
             send_auth(mechlist_data, nmechlist_data);
+            state = SREQ_S_WAIT;
         } else if (mechrc == MECH_UNAVAILABLE) {
-            // Do nothing - error already set
+            state = SREQ_S_ERROR;
         } else {
-            completed = !maybe_select_bucket();
+            state = SREQ_S_HELLODONE;
         }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_SASL_AUTH: {
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            completed = !maybe_select_bucket();
+            send_hello();
+            state = SREQ_S_AUTHDONE;
             break;
-        } else if (status == PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE) {
-            send_step(resp);
-        } else {
+        }
+
+        if (status != PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE) {
             set_error(LCB_AUTH_ERROR, "SASL AUTH failed");
+            state = SREQ_S_ERROR;
             break;
         }
+        if (send_step(resp) && send_hello()) {
+            state = SREQ_S_WAIT;
+        } else {
+            state = SREQ_S_ERROR;
+        }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_SASL_STEP: {
-        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            completed = !maybe_select_bucket();
-        } else {
+        if (status != PROTOCOL_BINARY_RESPONSE_SUCCESS) {
             lcb_log(LOGARGS(this, WARN), SESSREQ_LOGFMT "SASL auth failed with STATUS=0x%x", SESSREQ_LOGID(this), status);
             set_error(LCB_AUTH_ERROR, "SASL Step Failed");
+            state = SREQ_S_ERROR;
+        } else {
+            /* Wait for pipelined HELLO response */
+            state = SREQ_S_AUTHDONE;
         }
         break;
     }
 
     case PROTOCOL_BINARY_CMD_HELLO: {
+        state = SREQ_S_HELLODONE;
         if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
             if (!read_hello(resp)) {
                 set_error(LCB_PROTOCOL_ERROR, "Couldn't parse HELLO");
-                break;
             }
-        } else if (isUnsupported(status)) {
+        } else if (status == PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND ||
+                status == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED) {
             lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support HELLO", SESSREQ_LOGID(this));
+            /* nothing */
         } else {
             set_error(LCB_PROTOCOL_ERROR, "Hello response unexpected");
-            break;
-        }
-
-        if (info->has_feature(PROTOCOL_BINARY_FEATURE_XERROR)) {
-            request_errmap();
-        } else {
-            lcb_log(LOGARGS(this, TRACE), SESSREQ_LOGFMT "GET_ERRORMAP unsupported/disabled", SESSREQ_LOGID(this));
-        }
-
-        // In any event, it's also time to send the LIST_MECHS request
-        lcb::MemcachedRequest req(PROTOCOL_BINARY_CMD_SASL_LIST_MECHS);
-        lcbio_ctx_put(ctx, req.data(), req.size());
-        LCBIO_CTX_RSCHEDULE(ctx, 24);
-
-        break;
-    }
-
-    case PROTOCOL_BINARY_CMD_GET_ERROR_MAP: {
-        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            if (!update_errmap(resp)) {
-            }
-        } else if (isUnsupported(status)) {
-            lcb_log(LOGARGS(this, DEBUG), SESSREQ_LOGFMT "Server does not support GET_ERRMAP (0x%x)", SESSREQ_LOGID(this), status);
-        } else {
-            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for GET_ERRMAP", SESSREQ_LOGID(this), status);
-            set_error(LCB_PROTOCOL_ERROR, "GET_ERRMAP response unexpected");
-        }
-        // Note, there is no explicit state transition here. LIST_MECHS is
-        // pipelined after this request.
-        break;
-    }
-
-    case PROTOCOL_BINARY_CMD_SELECT_BUCKET: {
-        if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
-            completed = true;
-        } else if (status == PROTOCOL_BINARY_RESPONSE_EACCESS) {
-            set_error(LCB_AUTH_ERROR, "Provided credentials not allowed for bucket");
-        } else {
-            lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Unexpected status 0x%x received for SELECT_BUCKET", SESSREQ_LOGID(this), status);
-            set_error(LCB_PROTOCOL_ERROR, "Other auth error");
+            state = SREQ_S_ERROR;
         }
         break;
     }
 
     default: {
+        state = SREQ_S_ERROR;
         lcb_log(LOGARGS(this, ERROR), SESSREQ_LOGFMT "Received unknown response. OP=0x%x. RC=0x%x", SESSREQ_LOGID(this), resp.opcode(), resp.status());
         set_error(LCB_NOT_SUPPORTED, "Received unknown response");
         break;
@@ -586,7 +489,9 @@ SessionRequestImpl::handle_read(lcbio_CTX *ioctx)
     // or fail the request, potentially destroying the underlying connection
     if (has_error()) {
         fail();
-    } else if (completed) {
+    } else if (state == SREQ_S_ERROR) {
+        fail(LCB_ERROR, "FIXME: Error code set without description");
+    } else if (state == SREQ_S_HELLODONE) {
         success();
     } else {
         goto GT_NEXT_PACKET;
@@ -631,7 +536,8 @@ SessionRequestImpl::start(lcbio_SOCKET *sock) {
         return;
     }
 
-    send_hello();
+    lcb::MemcachedRequest hdr(PROTOCOL_BINARY_CMD_SASL_LIST_MECHS);
+    lcbio_ctx_put(ctx, hdr.data(), hdr.size());
     LCBIO_CTX_RSCHEDULE(ctx, 24);
 }
 

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

@@ -210,7 +210,8 @@ 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) : lcb_N1XSPEC() {
+    IndexSpec(const char *s, size_t n) {
+        memset(static_cast<lcb_N1XSPEC*>(this), 0, sizeof (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 : lcb::jsparse::Parser::Actions {
+typedef struct lcb_N1QLREQ {
     const lcb_RESPHTTP *cur_htresp;
     struct lcb_http_request_st *htreq;
-    lcb::jsparse::Parser *parser;
+    lcbjsp_PARSER *parser;
     const void *cookie;
     lcb_N1QLCALLBACK callback;
     lcb_t instance;
@@ -155,9 +155,6 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
     // 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;
 
@@ -230,28 +227,9 @@ typedef struct lcb_N1QLREQ : lcb::jsparse::Parser::Actions {
      */
     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
@@ -352,7 +330,8 @@ N1QLREQ::maybe_retry()
     }
 
     was_retried = true;
-    parser->get_postmortem(meta);
+
+    lcbjsp_get_postmortem(parser, &meta);
     if (!parse_json(static_cast<const char*>(meta.iov_base), meta.iov_len, root)) {
         return false; // Not JSON
     }
@@ -372,7 +351,7 @@ N1QLREQ::maybe_retry()
 
     } else {
         // We'll be parsing more rows later on..
-        parser->reset();
+        lcbjsp_reset(parser);
     }
     return true;
 }
@@ -387,7 +366,7 @@ N1QLREQ::invoke_row(lcb_RESPN1QL *resp, bool is_last)
         lcb_IOV meta;
         resp->rflags |= LCB_RESP_F_FINAL;
         resp->rc = lasterr;
-        parser->get_postmortem(meta);
+        lcbjsp_get_postmortem(parser, &meta);
         resp->row = static_cast<const char*>(meta.iov_base);
         resp->nrow = meta.iov_len;
     }
@@ -413,13 +392,31 @@ lcb_N1QLREQ::~lcb_N1QLREQ()
     }
 
     if (parser) {
-        delete parser;
+        lcbjsp_free(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)
 {
@@ -447,7 +444,8 @@ chunk_callback(lcb_t instance, int ign, const lcb_RESPBASE *rb)
         delete req;
         return;
     }
-    req->parser->feed(static_cast<const char*>(rh->body), rh->nbody);
+
+    lcbjsp_feed(req->parser, static_cast<const char*>(rh->body), rh->nbody);
 }
 
 #define QUERY_PATH "/query/service"
@@ -514,14 +512,7 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     htcmd.content_type = "application/json";
     htcmd.method = LCB_HTTP_METHOD_POST;
-
-    if (is_cbas()) {
-        htcmd.type = LCB_HTTP_TYPE_RAW;
-        htcmd.host = cbashost.c_str();
-    } else {
-        htcmd.type = LCB_HTTP_TYPE_N1QL;
-    }
-
+    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;
@@ -531,7 +522,7 @@ N1QLREQ::issue_htreq(const std::string& body)
 
     lcb_error_t rc = lcb_http3(instance, this, &htcmd);
     if (rc == LCB_SUCCESS) {
-        htreq->set_callback(chunk_callback);
+        lcb_htreq_setcb(htreq, chunk_callback);
     }
     return rc;
 }
@@ -595,12 +586,13 @@ 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(new lcb::jsparse::Parser(lcb::jsparse::Parser::MODE_N1QL, this)),
+    : cur_htresp(NULL), htreq(NULL), parser(lcbjsp_create(LCBJSP_MODE_N1QL)),
       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;
     }
@@ -612,22 +604,6 @@ 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();