libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/tools/cbc.cc

@@ -11,12 +11,17 @@
 #include <libcouchbase/n1ql.h>
 #include <limits>
 #include <stddef.h>
+#include <errno.h>
 #include "common/options.h"
 #include "common/histogram.h"
 #include "cbc-handlers.h"
 #include "connspec.h"
 #include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
 
+#ifndef LCB_NO_SSL
+#include <openssl/crypto.h>
+#endif
+
 using namespace cbc;
 
 using std::string;
@@ -34,11 +39,19 @@ string getRespKey(const lcb_RESPBASE* resp)
 }
 
 static void
-printKeyError(string& key, lcb_error_t err, const char *additional = NULL)
+printKeyError(string& key, int cbtype, const lcb_RESPBASE *resp, const char *additional = NULL)
 {
-    fprintf(stderr, "%-20s %s (0x%x)\n", key.c_str(), lcb_strerror(NULL, err), err);
+    fprintf(stderr, "%-20s %s (0x%x)\n", key.c_str(), lcb_strerror(NULL, resp->rc), resp->rc);
+    const char *ctx = lcb_resp_get_error_context(cbtype, resp);
+    if (ctx != NULL) {
+        fprintf(stderr, "%-20s %s\n", "", ctx);
+    }
+    const char *ref = lcb_resp_get_error_ref(cbtype, resp);
+    if (ref != NULL) {
+        fprintf(stderr, "%-20s Ref: %s\n", "", ref);
+    }
     if (additional) {
-        fprintf(stderr, "%-20s%s\n", "", additional);
+        fprintf(stderr, "%-20s %s\n", "", additional);
     }
 }
 
@@ -60,7 +73,7 @@ printKeyCasStatus(string& key, int cbtype, const lcb_RESPBASE *resp,
 
 extern "C" {
 static void
-get_callback(lcb_t, lcb_CALLBACKTYPE, const lcb_RESPGET *resp)
+get_callback(lcb_t, lcb_CALLBACKTYPE cbtype, const lcb_RESPGET *resp)
 {
     string key = getRespKey((const lcb_RESPBASE *)resp);
     if (resp->rc == LCB_SUCCESS) {
@@ -71,7 +84,7 @@ get_callback(lcb_t, lcb_CALLBACKTYPE, const lcb_RESPGET *resp)
         fflush(stdout);
         fprintf(stderr, "\n");
     } else {
-        printKeyError(key, resp->rc);
+        printKeyError(key, cbtype, (const lcb_RESPBASE *)resp);
     }
 }
 
@@ -96,13 +109,13 @@ store_callback(lcb_t, lcb_CALLBACKTYPE cbtype, const lcb_RESPBASE *resp)
             } else {
                 sprintf(buf, "%s", "Store failed");
             }
-            printKeyError(key, resp->rc, buf);
+            printKeyError(key, cbtype, resp);
         }
     } else {
         if (resp->rc == LCB_SUCCESS) {
             printKeyCasStatus(key, cbtype, resp, "Stored.");
         } else {
-            printKeyError(key, resp->rc);
+            printKeyError(key, cbtype, resp);
         }
     }
 }
@@ -112,7 +125,7 @@ common_callback(lcb_t, int type, const lcb_RESPBASE *resp)
 {
     string key = getRespKey(resp);
     if (resp->rc != LCB_SUCCESS) {
-        printKeyError(key, resp->rc);
+        printKeyError(key, type, resp);
         return;
     }
     switch (type) {
@@ -131,7 +144,7 @@ common_callback(lcb_t, int type, const lcb_RESPBASE *resp)
 }
 
 static void
-observe_callback(lcb_t, lcb_CALLBACKTYPE, const lcb_RESPOBSERVE *resp)
+observe_callback(lcb_t, lcb_CALLBACKTYPE cbtype, const lcb_RESPOBSERVE *resp)
 {
     if (resp->nkey == 0) {
         return;
@@ -144,7 +157,7 @@ observe_callback(lcb_t, lcb_CALLBACKTYPE, const lcb_RESPOBSERVE *resp)
             resp->ismaster ? "Master" : "Replica",
                     resp->status, resp->cas);
     } else {
-        printKeyError(key, resp->rc);
+        printKeyError(key, cbtype, (const lcb_RESPBASE *)resp);
     }
 }
 
@@ -180,7 +193,7 @@ static void
 stats_callback(lcb_t, lcb_CALLBACKTYPE, const lcb_RESPSTATS *resp)
 {
     if (resp->rc != LCB_SUCCESS) {
-        fprintf(stderr, "Got error %s (%d) in stats\n", lcb_strerror(NULL, resp->rc), resp->rc);
+        fprintf(stderr, "ERROR 0x%02X (%s)\n", resp->rc, lcb_strerror(NULL, resp->rc));
         return;
     }
     if (resp->server == NULL || resp->key == NULL) {
@@ -231,12 +244,24 @@ common_server_callback(lcb_t, int cbtype, const lcb_RESPSERVERBASE *sbase)
     }
 }
 
+static void
+ping_callback(lcb_t, int, const lcb_RESPPING *resp)
+{
+    if (resp->rc != LCB_SUCCESS) {
+        fprintf(stderr, "failed: %s\n", lcb_strerror(NULL, resp->rc));
+    } else {
+        if (resp->njson) {
+            printf("%.*s", (int)resp->njson, resp->json);
+        }
+    }
+}
+
 static void
 arithmetic_callback(lcb_t, lcb_CALLBACKTYPE type, const lcb_RESPCOUNTER *resp)
 {
     string key = getRespKey((const lcb_RESPBASE *)resp);
     if (resp->rc != LCB_SUCCESS) {
-        printKeyError(key, resp->rc);
+        printKeyError(key, type, (lcb_RESPBASE *)resp);
     } else {
         char buf[4096] = { 0 };
         sprintf(buf, "Current value is %" PRIu64 ".", resp->value);
@@ -403,21 +428,36 @@ GetHandler::run()
     lcb_install_callback3(instance, LCB_CALLBACK_GET, (lcb_RESPCALLBACK)get_callback);
     lcb_install_callback3(instance, LCB_CALLBACK_GETREPLICA, (lcb_RESPCALLBACK)get_callback);
     const vector<string>& keys = parser.getRestArgs();
-    lcb_error_t err;
+    std::string replica_mode = o_replica.result();
 
     lcb_sched_enter(instance);
     for (size_t ii = 0; ii < keys.size(); ++ii) {
-        lcb_CMDGET cmd = { 0 };
-        const string& key = keys[ii];
-        LCB_KREQ_SIMPLE(&cmd.key, key.c_str(), key.size());
-        if (o_exptime.passed()) {
-            cmd.exptime = o_exptime.result();
-        }
-        if (isLock()) {
-            cmd.lock = 1;
+        lcb_error_t err;
+        if (o_replica.passed()) {
+            lcb_CMDGETREPLICA cmd = { 0 };
+            const string& key = keys[ii];
+            LCB_KREQ_SIMPLE(&cmd.key, key.c_str(), key.size());
+            if (replica_mode == "first") {
+                cmd.strategy = LCB_REPLICA_FIRST;
+            } else if (replica_mode == "all") {
+                cmd.strategy = LCB_REPLICA_ALL;
+            } else {
+                cmd.strategy = LCB_REPLICA_SELECT;
+                cmd.index = std::atoi(replica_mode.c_str());
+            }
+            err = lcb_rget3(instance, this, &cmd);
+        } else {
+            lcb_CMDGET cmd = { 0 };
+            const string& key = keys[ii];
+            LCB_KREQ_SIMPLE(&cmd.key, key.c_str(), key.size());
+            if (o_exptime.passed()) {
+                cmd.exptime = o_exptime.result();
+            }
+            if (isLock()) {
+                cmd.lock = 1;
+            }
+            err = lcb_get3(instance, this, &cmd);
         }
-
-        err = lcb_get3(instance, this, &cmd);
         if (err != LCB_SUCCESS) {
             throw LcbError(err);
         }
@@ -763,11 +803,49 @@ VersionHandler::run()
     memset(&info, 0, sizeof info);
     err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &info);
     if (err == LCB_SUCCESS) {
-        fprintf(stderr, "  IO: Default=%s, Current=%s\n",
+        fprintf(stderr, "  IO: Default=%s, Current=%s, Accessible=",
             iops_to_string(info.v.v0.os_default), iops_to_string(info.v.v0.effective));
     }
-    printf("  SSL: .. %s\n",
-            lcb_supports_feature(LCB_SUPPORTS_SSL) ? "SUPPORTED" : "NOT SUPPORTED");
+    {
+        size_t ii;
+        char buf[256] = {0}, *p = buf;
+        lcb_io_ops_type_t known_io[] = {
+            LCB_IO_OPS_WINIOCP,
+            LCB_IO_OPS_LIBEVENT,
+            LCB_IO_OPS_LIBUV,
+            LCB_IO_OPS_LIBEV,
+            LCB_IO_OPS_SELECT
+        };
+
+
+        for (ii = 0; ii < sizeof(known_io) / sizeof(known_io[0]); ii++) {
+            struct lcb_create_io_ops_st cio = {0};
+            lcb_io_opt_t io = NULL;
+
+            cio.v.v0.type = known_io[ii];
+            if (lcb_create_io_ops(&io, &cio) == LCB_SUCCESS) {
+                p += sprintf(p, "%s,", iops_to_string(known_io[ii]));
+                lcb_destroy_io_ops(io);
+            }
+        }
+        *(--p) = '\n';
+        fprintf(stderr, "%s", buf);
+    }
+
+    if (lcb_supports_feature(LCB_SUPPORTS_SSL)) {
+#ifdef LCB_NO_SSL
+        printf("  SSL: SUPPORTED\n");
+#else
+#if defined(OPENSSL_VERSION)
+        printf("  SSL Runtime: %s\n", OpenSSL_version(OPENSSL_VERSION));
+#elif defined(SSLEAY_VERSION)
+        printf("  SSL Runtime: %s\n", SSLeay_version(SSLEAY_VERSION));
+#endif
+        printf("  SSL Headers: %s\n", OPENSSL_VERSION_TEXT);
+#endif
+    } else {
+        printf("  SSL: NOT SUPPORTED\n");
+    }
 }
 
 void
@@ -852,6 +930,28 @@ VerbosityHandler::run()
     lcb_wait(instance);
 }
 
+void
+PingHandler::run()
+{
+    Handler::run();
+
+    lcb_install_callback3(instance, LCB_CALLBACK_PING, (lcb_RESPCALLBACK)ping_callback);
+    lcb_CMDPING cmd = { 0 };
+    lcb_error_t err;
+    cmd.services = LCB_PINGSVC_F_KV | LCB_PINGSVC_F_N1QL | LCB_PINGSVC_F_VIEWS | LCB_PINGSVC_F_FTS;
+    cmd.options = LCB_PINGOPT_F_JSON | LCB_PINGOPT_F_JSONPRETTY;
+    if (o_details.passed()) {
+        cmd.options |= LCB_PINGOPT_F_JSONDETAILS;
+    }
+    lcb_sched_enter(instance);
+    err = lcb_ping3(instance, NULL, &cmd);
+    if (err != LCB_SUCCESS) {
+        throw LcbError(err);
+    }
+    lcb_sched_leave(instance);
+    lcb_wait(instance);
+}
+
 void
 McFlushHandler::run()
 {
@@ -979,11 +1079,11 @@ extern "C" {
 static void n1qlCallback(lcb_t, int, const lcb_RESPN1QL *resp)
 {
     if (resp->rflags & LCB_RESP_F_FINAL) {
-        fprintf(stderr, "** N1QL Response finished\n");
+        fprintf(stderr, "---> Query response finished\n");
         if (resp->rc != LCB_SUCCESS) {
-            fprintf(stderr, "N1QL query failed with library code 0x%x\n", resp->rc);
+            fprintf(stderr, "---> Query failed with library code 0x%x (%s)\n", resp->rc, lcb_strerror(NULL, resp->rc));
             if (resp->htresp) {
-                fprintf(stderr, "Inner HTTP request failed with library code 0x%x and HTTP status %d\n",
+                fprintf(stderr, "---> Inner HTTP request failed with library code 0x%x and HTTP status %d\n",
                     resp->htresp->rc, resp->htresp->htstatus);
             }
         }
@@ -1039,7 +1139,10 @@ N1qlHandler::run()
     if (o_prepare.passed()) {
         cmd.cmdflags |= LCB_CMDN1QL_F_PREPCACHE;
     }
-    fprintf(stderr, "Encoded query: %.*s\n", (int)cmd.nquery, cmd.query);
+    if (o_analytics.passed()) {
+        cmd.cmdflags |= LCB_CMDN1QL_F_CBASQUERY;
+    }
+    fprintf(stderr, "---> Encoded query: %.*s\n", (int)cmd.nquery, cmd.query);
     cmd.callback = n1qlCallback;
     rc = lcb_n1ql_query(instance, NULL, &cmd);
     if (rc != LCB_SUCCESS) {
@@ -1348,7 +1451,6 @@ ConnstrHandler::run()
     lcb_error_t err;
     const char *errmsg;
     lcb::Connspec spec;
-    memset(&spec, 0, sizeof spec);
     err = spec.parse(connstr_s.c_str(), &errmsg);
     if (err != LCB_SUCCESS) {
         throw BadArg(errmsg);
@@ -1362,6 +1464,8 @@ ConnstrHandler::run()
         if (spec.sslopts() & LCB_SSL_NOVERIFY) {
             sslOpts += "|NOVERIFY";
         }
+    } else {
+        sslOpts = "DISABLED";
     }
     printf("SSL: %s\n", sslOpts.c_str());
 
@@ -1455,7 +1559,7 @@ static const char* optionsOrder[] = {
         "version",
         "verbosity",
         "view",
-        "n1ql",
+        "query",
         "admin",
         "bucket-create",
         "bucket-delete",
@@ -1467,6 +1571,7 @@ static const char* optionsOrder[] = {
         "connstr",
         "write-config",
         "strerror",
+        "ping",
         NULL
 };
 
@@ -1536,6 +1641,7 @@ setupHandlers()
     handlers_s["cp"] = new SetHandler("cp");
     handlers_s["stats"] = new StatsHandler();
     handlers_s["verbosity"] = new VerbosityHandler();
+    handlers_s["ping"] = new PingHandler();
     handlers_s["mcflush"] = new McFlushHandler();
     handlers_s["incr"] = new IncrHandler();
     handlers_s["decr"] = new DecrHandler();
@@ -1544,7 +1650,7 @@ setupHandlers()
     handlers_s["bucket-delete"] = new BucketDeleteHandler();
     handlers_s["bucket-flush"] = new BucketFlushHandler();
     handlers_s["view"] = new ViewsHandler();
-    handlers_s["n1ql"] = new N1qlHandler();
+    handlers_s["query"] = new N1qlHandler();
     handlers_s["connstr"] = new ConnstrHandler();
     handlers_s["write-config"] = new WriteConfigHandler();
     handlers_s["strerror"] = new StrErrorHandler();
@@ -1561,6 +1667,7 @@ setupHandlers()
     }
 
     handlers["cat"] = handlers["get"];
+    handlers["n1ql"] = handlers["query"];
 }
 
 #if _POSIX_VERSION >= 200112L
@@ -1604,7 +1711,8 @@ wrapExternalBinary(int argc, char **argv, const std::string& name)
     size_t cbc_pos = exePath.find("cbc");
 
     if (cbc_pos == string::npos) {
-        throw BadArg("Couldn't invoke " + name);
+        fprintf(stderr, "Failed to invoke %s (%s)\n", name.c_str(), exePath.c_str());
+        exit(EXIT_FAILURE);
     }
 
     exePath.replace(cbc_pos, 3, name);
@@ -1617,11 +1725,11 @@ wrapExternalBinary(int argc, char **argv, const std::string& name)
     }
     args.push_back((char*)NULL);
     execvp(exePath.c_str(), &args[0]);
-    perror(exePath.c_str());
-    throw BadArg("Couldn't execute " + name + " !");
+    fprintf(stderr, "Failed to execute execute %s (%s): %s\n", name.c_str(), exePath.c_str(), strerror(errno));
 #else
-    throw BadArg("Can't wrap around " + name + " on non-POSIX environments");
+    fprintf(stderr, "Can't wrap around %s on non-POSIX environments", name.c_str());
 #endif
+    exit(EXIT_FAILURE);
 }
 
 static void cleanupHandlers()
@@ -1641,6 +1749,10 @@ int main(int argc, char **argv)
             wrapExternalBinary(argc, argv, "cbc-pillowfight");
         } else if (strcmp(argv[1], "n1qlback") == 0) {
             wrapExternalBinary(argc, argv, "cbc-n1qlback");
+        } else if (strcmp(argv[1], "subdoc") == 0) {
+            wrapExternalBinary(argc, argv, "cbc-subdoc");
+        } else if (strcmp(argv[1], "proxy") == 0) {
+            wrapExternalBinary(argc, argv, "cbc-proxy");
         }
     }
 

data/ext/libcouchbase/tools/common/options.h

@@ -34,8 +34,11 @@ namespace cbc {
 
 class LcbError : public std::runtime_error {
 private:
-    static std::string format_err(lcb_error_t err) {
+    static std::string format_err(lcb_error_t err, std::string msg) {
         std::stringstream ss;
+        if (!msg.empty()) {
+            ss << msg << ". ";
+        }
         ss << "libcouchbase error: " << lcb_strerror(NULL, err);
         ss << " (0x" << std::hex << err << ")";
         return ss.str();
@@ -43,7 +46,7 @@ private:
 
 public:
     lcb_error_t rc;
-    LcbError(lcb_error_t code) : std::runtime_error(format_err(code)) {}
+    LcbError(lcb_error_t code, std::string msg = "") : std::runtime_error(format_err(code, msg)) {}
 };
 
 class BadArg : public std::runtime_error {

data/ext/libcouchbase/tools/linenoise/linenoise.c

@@ -173,7 +173,6 @@ enum KEY_ACTION{
 };
 
 static void linenoiseAtExit(void);
-int linenoiseHistoryAdd(const char *line);
 static void refreshLine(struct linenoiseState *l);
 
 /* Debugging macro. */
@@ -192,7 +191,7 @@ FILE *lndebug_fp = NULL;
         fflush(lndebug_fp); \
     } while (0)
 #else
-#define lndebug(fmt, ...)
+#define lndebug(...)
 #endif
 
 /* ======================= Low level terminal handling ====================== */
@@ -473,7 +472,7 @@ static void abFree(struct abuf *ab) {
 
 /* Helper of refreshSingleLine() and refreshMultiLine() to show hints
  * to the right of the prompt. */
-void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
+static void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
     char seq[64];
     if (hintsCallback && plen+l->len < l->cols) {
         int color = -1, bold = 0;
@@ -635,7 +634,7 @@ static void refreshLine(struct linenoiseState *l) {
 /* Insert the character 'c' at cursor current position.
  *
  * On error writing to the terminal -1 is returned, otherwise 0. */
-int linenoiseEditInsert(struct linenoiseState *l, char c) {
+static int linenoiseEditInsert(struct linenoiseState *l, char c) {
     if (l->len < l->buflen) {
         if (l->len == l->pos) {
             l->buf[l->pos] = c;
@@ -662,7 +661,7 @@ int linenoiseEditInsert(struct linenoiseState *l, char c) {
 }
 
 /* Move cursor on the left. */
-void linenoiseEditMoveLeft(struct linenoiseState *l) {
+static void linenoiseEditMoveLeft(struct linenoiseState *l) {
     if (l->pos > 0) {
         l->pos--;
         refreshLine(l);
@@ -670,7 +669,7 @@ void linenoiseEditMoveLeft(struct linenoiseState *l) {
 }
 
 /* Move cursor on the right. */
-void linenoiseEditMoveRight(struct linenoiseState *l) {
+static void linenoiseEditMoveRight(struct linenoiseState *l) {
     if (l->pos != l->len) {
         l->pos++;
         refreshLine(l);
@@ -678,7 +677,7 @@ void linenoiseEditMoveRight(struct linenoiseState *l) {
 }
 
 /* Move cursor to the start of the line. */
-void linenoiseEditMoveHome(struct linenoiseState *l) {
+static void linenoiseEditMoveHome(struct linenoiseState *l) {
     if (l->pos != 0) {
         l->pos = 0;
         refreshLine(l);
@@ -686,7 +685,7 @@ void linenoiseEditMoveHome(struct linenoiseState *l) {
 }
 
 /* Move cursor to the end of the line. */
-void linenoiseEditMoveEnd(struct linenoiseState *l) {
+static void linenoiseEditMoveEnd(struct linenoiseState *l) {
     if (l->pos != l->len) {
         l->pos = l->len;
         refreshLine(l);
@@ -697,7 +696,7 @@ void linenoiseEditMoveEnd(struct linenoiseState *l) {
  * entry as specified by 'dir'. */
 #define LINENOISE_HISTORY_NEXT 0
 #define LINENOISE_HISTORY_PREV 1
-void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
+static void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
     if (history_len > 1) {
         /* Update the current history entry before to
          * overwrite it with the next one. */
@@ -721,7 +720,7 @@ void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
 
 /* Delete the character at the right of the cursor without altering the cursor
  * position. Basically this is what happens with the "Delete" keyboard key. */
-void linenoiseEditDelete(struct linenoiseState *l) {
+static void linenoiseEditDelete(struct linenoiseState *l) {
     if (l->len > 0 && l->pos < l->len) {
         memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1);
         l->len--;
@@ -731,7 +730,7 @@ void linenoiseEditDelete(struct linenoiseState *l) {
 }
 
 /* Backspace implementation. */
-void linenoiseEditBackspace(struct linenoiseState *l) {
+static void linenoiseEditBackspace(struct linenoiseState *l) {
     if (l->pos > 0 && l->len > 0) {
         memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos);
         l->pos--;
@@ -743,7 +742,7 @@ void linenoiseEditBackspace(struct linenoiseState *l) {
 
 /* Delete the previosu word, maintaining the cursor at the start of the
  * current word. */
-void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
+static void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
     size_t old_pos = l->pos;
     size_t diff;
 
@@ -804,11 +803,12 @@ static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen,
          * there was an error reading from fd. Otherwise it will return the
          * character that should be handled next. */
         if (c == 9 && completionCallback != NULL) {
-            c = completeLine(&l);
+            int r = completeLine(&l);
             /* Return on errors */
-            if (c < 0) return l.len;
+            if (r < 0) return l.len;
             /* Read next character when 0 */
-            if (c == 0) continue;
+            if (r == 0) continue;
+            c = (char)r;
         }
 
         switch(c) {