libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/handler.cc

@@ -822,6 +822,8 @@ mcreq_dispatch_response(
     break;
 
     switch (res->opcode()) {
+    case PROTOCOL_BINARY_CMD_GETQ:
+    case PROTOCOL_BINARY_CMD_GATQ:
     case PROTOCOL_BINARY_CMD_GET:
     case PROTOCOL_BINARY_CMD_GAT:
     case PROTOCOL_BINARY_CMD_GET_LOCKED:

data/ext/libcouchbase/src/hostlist.cc

@@ -16,6 +16,7 @@
  */
 
 #include "hostlist.h"
+#include "simplestring.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <limits.h>
@@ -263,3 +264,38 @@ Hostlist::assign(const Hostlist& src)
     }
     return *this;
 }
+
+extern "C" {
+Hostlist* hostlist_create(void) { return new Hostlist(); }
+void hostlist_destroy(hostlist_t l) { delete l; }
+void hostlist_clear(hostlist_t l) { l->clear(); }
+void hostlist_reset_strlist(hostlist_t l) { l->reset_strlist(); }
+lcb_error_t hostlist_add_host(hostlist_t l, const lcb_host_t *h) { l->add(*h); return LCB_SUCCESS; }
+lcb_host_t *hostlist_shift_next(hostlist_t hl, int wrap) { return hl->next(wrap); }
+int hostlist_finished(hostlist_t l) { return l->ix == l->hosts.size(); }
+size_t hostlist_size(hostlist_t l) { return l->size(); }
+void hostlist_randomize(hostlist_t l) { l->randomize(); }
+
+lcb_error_t
+hostlist_add_string(hostlist_t hl, const char *spec, int len, int deflport) {
+    return hl->add(spec, len, deflport);
+}
+
+void
+hostlist_assign(hostlist_t dst, const hostlist_t src) {
+    dst->assign(*src);
+}
+
+const lcb_host_t*
+hostlist_get(const hostlist_t h, size_t ix) { return &h->hosts[ix]; }
+
+const char * const *
+hostlist_strents(const hostlist_t h) {
+    h->ensure_strlist();
+    if (h->hoststrs.size()) {
+        return &h->hoststrs[0];
+    } else {
+        return NULL;
+    }
+}
+}

data/ext/libcouchbase/src/hostlist.h

@@ -45,56 +45,21 @@ struct Hostlist {
     Hostlist() : ix(0) {}
     ~Hostlist();
 
-    /**
-     * Adds a string to the hostlist. See lcb_host_parse for details.
-     * Note that if the host already exists (see 'lcb_host_equals') it will
-     * not be added
-     * @param s the string to parse
-     * @param len the length of the string
-     * @param deflport If `s` does not contain an explicit port, use this
-     *        port instead.
-     * @return LCB_EINVAL if the host string is not valid
-     */
+    void add(const lcb_host_t&);
     lcb_error_t add(const char *s, long len, int deflport);
     lcb_error_t add(const char *s, int deflport) { return add(s, -1, deflport); }
-    void add(const lcb_host_t&);
-
     bool exists(const lcb_host_t&) const;
     bool exists(const char *hostport) const;
-
-    /**
-     * Return the next host in the list.
-     * @param wrap If the internal iterator has reached its limit, this
-     * indicates whether it should be reset, or if it should return NULL
-     * @return a new host if available, or NULL if the list is empty or the
-     * iterator is finished.
-     */
     lcb_host_t *next(bool wrap);
     bool finished() const;
 
     size_t size() const { return hosts.size(); }
     bool empty() const { return hosts.empty(); }
     Hostlist& assign(const Hostlist& other);
-
-    /** Clears the hostlist */
     void clear() { hosts.clear(); reset_strlist(); ix = 0; }
-
-    /** Randomize the hostlist by shuffling the order. */
     void randomize();
-
-    /**
-     * String list handling functions. These are used to return the hostlist via
-     * the API where we return a char*[] terminated by a NULL pointer.
-     */
-
-    /** Ensure that the string list contains at least one entry */
     void ensure_strlist();
-
-    /** Frees the current list of strings */
     void reset_strlist();
-
-    const char * const *get_strlist() const { return &hoststrs[0]; }
-
     unsigned int ix;
     const lcb_host_t& operator[](size_t ix_) const { return hosts[ix_]; }
 
@@ -103,16 +68,28 @@ struct Hostlist {
 };
 }
 typedef lcb::Hostlist* hostlist_t;
-
-struct hostlist_st : lcb::Hostlist {
-    hostlist_st() : Hostlist() {
-    }
-};
+#define hostlist_st lcb::Hostlist
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+/**
+ * Creates a new hostlist. Returns NULL on allocation failure
+ */
+hostlist_t hostlist_create(void);
+
+/**
+ * Frees resources associated with the hostlist
+ */
+void hostlist_destroy(hostlist_t hostlist);
+
+/**
+ * Clears the hostlist
+ */
+void hostlist_clear(hostlist_t hostlist);
+
 /**
  * Parses a string into a hostlist
  * @param host the target host to populate
@@ -144,6 +121,50 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport);
  */
 int lcb_host_equals(const lcb_host_t *a, const lcb_host_t *b);
 
+/**
+ * Adds a string to the hostlist. See lcb_host_parse for details.
+ * Note that if the host already exists (see 'lcb_host_equals') it will
+ * not be added
+ * @return LCB_EINVAL if the host string is not value, LCB_CLIENT_ENOMEM on
+ * allocation failure.
+ */
+lcb_error_t hostlist_add_string(hostlist_t hostlist,
+                                const char *spec,
+                                int speclen,
+                                int deflport);
+
+#define hostlist_add_stringz(hostlist, spec, deflport) \
+    hostlist_add_string(hostlist, spec, -1, deflport)
+
+lcb_error_t hostlist_add_host(hostlist_t hostlist, const lcb_host_t *host);
+
+/**
+ * Return the next host in the list.
+ * @param hostlist the hostlist to use
+ * @param rollover If the internal iterator has reached its limit, this
+ * indicates whether it should be reset, or if it should return NULL
+ * @return a new host if available, or NULL if the list is empty or the
+ * iterator is finished.
+ */
+lcb_host_t *hostlist_shift_next(hostlist_t hostlist, int rollover);
+
+/**
+ * Randomize the hostlist
+ */
+void hostlist_randomize(hostlist_t hostlist);
+
+/**
+ * String list handling functions. These are used to return the hostlist via
+ * the API where we return a char*[] terminated by a NULL pointer.
+ */
+void hostlist_reset_strlist(hostlist_t hostlist);
+
+/** Whether the internal iterator has finished. */
+int hostlist_finished(hostlist_t);
+size_t hostlist_size(const hostlist_t hl);
+void hostlist_assign(hostlist_t dst, const hostlist_t src);
+const lcb_host_t *hostlist_get(const hostlist_t, size_t);
+const char * const *hostlist_strents(const hostlist_t hl);
 #ifdef __cplusplus
 }
 #endif

data/ext/libcouchbase/src/http/http-priv.h

@@ -21,7 +21,6 @@
 #include <libcouchbase/couchbase.h>
 #include <lcbio/lcbio.h>
 #include <lcbio/timer-ng.h>
-#include <lcbio/timer-cxx.h>
 #include <lcbht/lcbht.h>
 #include "contrib/http_parser/http_parser.h"
 #include "http.h"
@@ -42,34 +41,100 @@ struct Header {
 };
 
 struct Request {
+    enum State {
+        /**
+         * The request is still ongoing. Callbacks are still active.
+         * Note that this essentially means the absence of any flags :)
+         */
+        ONGOING = 0,
+
+        /**
+         * This flag is set when the on_complete callback has been invoked. This
+         * is used as a marker to prevent us from calling that callback more than
+         * once per request
+         */
+        CBINVOKED = 1 << 0,
+
+        /**
+         * This flag is set by lcb_http_request_finish, and indicates that the
+         * request is no longer active per se. This means that while the request
+         * may still be valid in memory, it is simply waiting for any pending I/O
+         * operations to close, so the reference count can hit zero.
+         */
+        FINISHED = 1 << 1,
+
+        /**
+         * Internal flag used to indicate that finish() should not not attempt
+         * to modify any instance-level globals. This is currently used
+         * from within lcb_destroy()
+         */
+        NOLCB = 1 << 2
+    };
+
+    lcb_t instance; /**< Library handle */
+    std::string url; /**<Base URL: http://host:port/path?query*/
+    std::string host; /**< Host, derived from URL */
+    std::string port; /**< Port, derived from URL */
+
+    std::string pending_redirect; /**< New redirected URL */
+    bool has_pending_redirect() const { return !pending_redirect.empty(); }
+    const std::vector<char> body; /**< Input body (for POST/PUT) */
+
+    /** Request buffer (excluding body). Reassembled from inputs */
+    std::vector<char> preamble;
+
+    struct http_parser_url url_info; /**< Parser info for the URL */
+    const lcb_http_method_t method; /**< Request method constant */
+    const bool chunked; /**< Whether to invoke callback for each data chunk */
+    bool paused; /**< See pause() and resume() */
+    const void * const command_cookie; /** User context for callback */
+    size_t refcount; /** Initialized to 1. See incref() and decref() */
+    int redircount; /** Times this request was redirected */
+
     /**
-     * Initializes the request. This simply copies the relevant fields from the
-     * body and initializes instance members to their default values. The static
-     * ::create() method should be used instead to construct a new object
+     * Whether this request has delivered data to the user. This is relevant
+     * in cases where a retry is requested. If any data has been passed at
+     * all, we cannot retry the request.
      */
-    inline Request(lcb_t instance, const void *cookie, const lcb_CMDHTTP* cmd);
-
-    /** Creates a new request object and verifies the input (setup_inputs()) */
-    static Request * create(lcb_t instance, const void *cookie,
-        const lcb_CMDHTTP *cmd, lcb_error_t *rc);
+    bool passed_data;
 
-    /** Pause IO on this request */
-    void pause();
+    /** Sparse map indicating which nodes the request was already sent to */
+    std::vector<int> used_nodes;
 
-    /** Resume previously paused IO */
-    void resume();
+    /**
+     * Last revision ID of vBucket config. If the current revision does not
+     * match this number, the ::used_nodes field is cleared
+     */
+    int last_vbcrev;
 
-    /** Cancel and finish this request, suppressing callbacks */
-    void cancel();
+    const lcb_http_type_t reqtype; /**< HTTP API type */
+    int status; /**< OR'd flags of ::State */
+    std::vector<Header> request_headers; /**< List of request headers */
 
     /**
-     * Start all operations required to make this request. This should be
-     * called once all inputs have been completed. If successful, I/O operations
-     * will begin (this function calls start_io())
+     * Response headers for callback (array of char*). Buffers are mapped to
+     * ::response_headers
      */
-    lcb_error_t submit();
+    std::vector<const char*> response_headers_clist;
+
+    /** Backing buffers for response headers */
+    std::vector<Header> response_headers;
+
+    /** Callback to invoke */
+    lcb_RESPCALLBACK callback;
+
+    // IO variables
+    lcbio_pTABLE io;
+    lcbio_pCTX ioctx;
+    lcbio_pTIMER timer;
+    lcbio_CONNREQ creq;
+
+    /** HTTP Protocol parser */
+    lcbht_pPARSER parser;
+
+    /** overrides default timeout if nonzero */
+    const uint32_t user_timeout;
 
-    bool has_pending_redirect() const { return !pending_redirect.empty(); }
     /**
      * @return The effective timeout. This is either the user timeout or the
      * default timeout for the API type
@@ -87,6 +152,13 @@ struct Request {
      */
     bool is_ongoing() const { return status == ONGOING; }
 
+    /**
+     * Initializes the request. This simply copies the relevant fields from the
+     * body and initializes instance members to their default values. The static
+     * ::create() method should be used instead to construct a new object
+     */
+    inline Request(lcb_t instance, const void *cookie, const lcb_CMDHTTP* cmd);
+
     /**
      * Sets up inputs from the command. This should really be in the
      * constructor, however we also need a return value. The ::create()
@@ -108,6 +180,10 @@ struct Request {
     const char *get_api_node(lcb_error_t &rc);
     const char *get_api_node() { lcb_error_t dummy; return get_api_node(dummy); }
 
+    /** Creates a new request object and verifies the input (setup_inputs()) */
+    static Request * create(lcb_t instance, const void *cookie,
+        const lcb_CMDHTTP *cmd, lcb_error_t *rc);
+
     /**
      * Sets the URL for the field
      * @param base The URL base (i.e. http://foo.com)
@@ -144,6 +220,13 @@ struct Request {
     inline void add_to_preamble(const std::string&);
     inline void add_to_preamble(const Header&);
 
+    /**
+     * Start all operations required to make this request. This should be
+     * called once all inputs have been completed. If successful, I/O operations
+     * will begin (this function calls start_io())
+     */
+    lcb_error_t submit();
+
     /**
      * Starts the IO on the current request. This really belongs in submit(),
      * but submit() handles building the request while start_io() sets up
@@ -158,7 +241,7 @@ struct Request {
 
     // Helper functions for parsing response data from network
     inline int handle_parse_chunked(const char *buf, unsigned nbuf);
-    inline void assign_response_headers(const lcb::htparse::Response&);
+    inline void assign_response_headers(const lcbht_RESPONSE*);
 
     /**
      * Called when a redirect has happened. pending_redirect must not be empty.
@@ -190,15 +273,14 @@ struct Request {
      **/
     void finish_or_retry(lcb_error_t rc);
 
-    /**
-     * Change the callback for this request. This is used to indicate that
-     * a custom internal callback is used, rather than the one installed via
-     * lcb_install_callback3
-     * @param callback_ The internal callback to invoke
-     */
-    void set_callback(lcb_RESPCALLBACK callback_) {
-        callback = callback_;
-    }
+    /** Pause IO on this request */
+    void pause();
+
+    /** Resume previously paused IO */
+    void resume();
+
+    /** Cancel and finish this request, suppressing callbacks */
+    void cancel();
 
     /**
      * Let the request finish its normal course, suppressing any callbacks.
@@ -215,101 +297,6 @@ struct Request {
 
     /** Increment refcount */
     void incref() { refcount++; }
-
-    lcb_t instance; /**< Library handle */
-    std::string url; /**<Base URL: http://host:port/path?query*/
-    std::string host; /**< Host, derived from URL */
-    std::string port; /**< Port, derived from URL */
-
-    std::string pending_redirect; /**< New redirected URL */
-
-    const std::vector<char> body; /**< Input body (for POST/PUT) */
-
-    /** Request buffer (excluding body). Reassembled from inputs */
-    std::vector<char> preamble;
-
-    struct http_parser_url url_info; /**< Parser info for the URL */
-    const lcb_http_method_t method; /**< Request method constant */
-    const bool chunked; /**< Whether to invoke callback for each data chunk */
-    bool paused; /**< See pause() and resume() */
-    const void * const command_cookie; /** User context for callback */
-    size_t refcount; /** Initialized to 1. See incref() and decref() */
-    int redircount; /** Times this request was redirected */
-
-    /**
-     * Whether this request has delivered data to the user. This is relevant
-     * in cases where a retry is requested. If any data has been passed at
-     * all, we cannot retry the request.
-     */
-    bool passed_data;
-
-    /** Sparse map indicating which nodes the request was already sent to */
-    std::vector<int> used_nodes;
-
-    /**
-     * Last revision ID of vBucket config. If the current revision does not
-     * match this number, the ::used_nodes field is cleared
-     */
-    int last_vbcrev;
-
-    const lcb_http_type_t reqtype; /**< HTTP API type */
-
-
-    enum State {
-        /**
-         * The request is still ongoing. Callbacks are still active.
-         * Note that this essentially means the absence of any flags :)
-         */
-        ONGOING = 0,
-
-        /**
-         * This flag is set when the on_complete callback has been invoked. This
-         * is used as a marker to prevent us from calling that callback more than
-         * once per request
-         */
-        CBINVOKED = 1 << 0,
-
-        /**
-         * This flag is set by lcb_http_request_finish, and indicates that the
-         * request is no longer active per se. This means that while the request
-         * may still be valid in memory, it is simply waiting for any pending I/O
-         * operations to close, so the reference count can hit zero.
-         */
-        FINISHED = 1 << 1,
-
-        /**
-         * Internal flag used to indicate that finish() should not not attempt
-         * to modify any instance-level globals. This is currently used
-         * from within lcb_destroy()
-         */
-        NOLCB = 1 << 2
-    };
-    int status; /**< OR'd flags of ::State */
-    std::vector<Header> request_headers; /**< List of request headers */
-
-    /**
-     * Response headers for callback (array of char*). Buffers are mapped to
-     * ::response_headers
-     */
-    std::vector<const char*> response_headers_clist;
-
-    /** Backing buffers for response headers */
-    std::vector<lcb::htparse::MimeHeader> response_headers;
-
-    /** Callback to invoke */
-    lcb_RESPCALLBACK callback;
-
-    // IO variables
-    lcbio_pTABLE io;
-    lcbio_pCTX ioctx;
-    lcbio_pTIMER timer;
-    lcbio_CONNREQ creq;
-
-    /** HTTP Protocol parser */
-    lcb::htparse::Parser* parser;
-
-    /** overrides default timeout if nonzero */
-    const uint32_t user_timeout;
 };
 
 } // namespace: http