libcouchbase 0.0.7 → 0.0.8

data/ext/libcouchbase/src/hostlist.cc

@@ -16,7 +16,6 @@
  */
 
 #include "hostlist.h"
-#include "simplestring.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <limits.h>

data/ext/libcouchbase/src/hostlist.h

@@ -65,10 +65,15 @@ struct Hostlist {
 
     std::vector<lcb_host_t> hosts;
     std::vector<const char *> hoststrs;
+    static Hostlist* from_c(hostlist_st* src) {
+        return reinterpret_cast<Hostlist*>(src);
+    }
 };
 }
 typedef lcb::Hostlist* hostlist_t;
-#define hostlist_st lcb::Hostlist
+
+struct hostlist_st : lcb::Hostlist {
+};
 #endif
 
 #ifdef __cplusplus

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

@@ -21,6 +21,7 @@
 #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"
@@ -41,100 +42,34 @@ 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 */
-
     /**
-     * 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.
+     * 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
      */
-    bool passed_data;
+    inline Request(lcb_t instance, const void *cookie, const lcb_CMDHTTP* cmd);
 
-    /** Sparse map indicating which nodes the request was already sent to */
-    std::vector<int> used_nodes;
+    /** 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);
 
-    /**
-     * Last revision ID of vBucket config. If the current revision does not
-     * match this number, the ::used_nodes field is cleared
-     */
-    int last_vbcrev;
+    /** Pause IO on this request */
+    void pause();
 
-    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 */
+    /** Resume previously paused IO */
+    void resume();
+
+    /** Cancel and finish this request, suppressing callbacks */
+    void cancel();
 
     /**
-     * Response headers for callback (array of char*). Buffers are mapped to
-     * ::response_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())
      */
-    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;
+    lcb_error_t submit();
 
+    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
@@ -152,13 +87,6 @@ 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()
@@ -180,10 +108,6 @@ 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)
@@ -220,13 +144,6 @@ 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
@@ -241,7 +158,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 lcbht_RESPONSE*);
+    inline void assign_response_headers(const lcb::htparse::Response&);
 
     /**
      * Called when a redirect has happened. pending_redirect must not be empty.
@@ -273,14 +190,15 @@ struct Request {
      **/
     void finish_or_retry(lcb_error_t rc);
 
-    /** Pause IO on this request */
-    void pause();
-
-    /** Resume previously paused IO */
-    void resume();
-
-    /** Cancel and finish this request, suppressing callbacks */
-    void cancel();
+    /**
+     * 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_;
+    }
 
     /**
      * Let the request finish its normal course, suppressing any callbacks.
@@ -297,6 +215,101 @@ 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

data/ext/libcouchbase/src/http/http.cc

@@ -43,7 +43,7 @@ Request::decref()
     close_io();
 
     if (parser) {
-        lcbht_free(parser);
+        delete parser;
     }
 
     if (timer) {
@@ -103,7 +103,6 @@ void
 Request::maybe_refresh_config(lcb_error_t err)
 {
     int htstatus_ok;
-    lcbht_RESPONSE *resp;
     if (!parser) {
         return;
     }
@@ -112,25 +111,25 @@ Request::maybe_refresh_config(lcb_error_t err)
         return;
     }
 
-    resp = lcbht_get_response(parser);
-    htstatus_ok = resp->status >= 200 && resp->status < 299;
+    const lcb::htparse::Response& resp = parser->get_cur_response();
+    htstatus_ok = resp.status >= 200 && resp.status < 299;
 
     if (err != LCB_SUCCESS && (err == LCB_ESOCKSHUTDOWN && htstatus_ok) == 0) {
         /* ignore graceful close */
-        lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+        instance->bootstrap(BS_REFRESH_ALWAYS);
         return;
     }
 
     if (htstatus_ok) {
         return;
     }
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+    instance->bootstrap(BS_REFRESH_ALWAYS);
 }
 
 void
 Request::init_resp(lcb_RESPHTTP *res)
 {
-    const lcbht_RESPONSE *htres = lcbht_get_response(parser);
+    const lcb::htparse::Response& htres = parser->get_cur_response();
 
     res->cookie = const_cast<void*>(command_cookie);
     res->key = url.c_str() + url_info.field_data[UF_PATH].off;
@@ -139,9 +138,7 @@ Request::init_resp(lcb_RESPHTTP *res)
     if (!response_headers.empty()) {
         res->headers = &response_headers_clist[0];
     }
-    if (htres) {
-        res->htstatus = htres->status;
-    }
+    res->htstatus = htres.status;
 }
 
 void
@@ -254,9 +251,9 @@ Request::submit()
         // Only wipe old parser/response information if current I/O request
         // was a success
         if (parser) {
-            lcbht_reset(parser);
+            parser->reset();
         } else {
-            parser = lcbht_new(instance->settings);
+            parser = new lcb::htparse::Parser(instance->settings);
         }
         response_headers.clear();
         response_headers_clist.clear();
@@ -613,23 +610,6 @@ Request::cancel()
     finish(LCB_SUCCESS);
 }
 
-// Wrappers
-void lcb_htreq_setcb(lcb_http_request_t req, lcb_RESPCALLBACK callback) {
-    req->callback = callback;
-}
-void lcb_htreq_block_callback(lcb_http_request_t req) {
-    req->block_callback();
-}
-void lcb_htreq_pause(lcb_http_request_t req) {
-    req->pause();
-}
-void lcb_htreq_resume(lcb_http_request_t req) {
-    req->resume();
-}
-void lcb_htreq_finish(lcb_t, lcb_http_request_t req, lcb_error_t rc) {
-    req->finish(rc);
-}
-
 LIBCOUCHBASE_API
 void
 lcb_cancel_http_request(lcb_t, lcb_http_request_t req)

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

@@ -1,34 +1 @@
-#ifndef LCB_HTTPAPI_H
-#define LCB_HTTPAPI_H
-
-/* This file contains the internal API for HTTP requests. This allows us to
- * change the internals without exposing the object structure to the rest
- * of the library
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void
-lcb_htreq_setcb(lcb_http_request_t, lcb_RESPCALLBACK);
-
-void
-lcb_htreq_pause(lcb_http_request_t);
-
-void
-lcb_htreq_resume(lcb_http_request_t);
-
-void
-lcb_htreq_finish(lcb_t, lcb_http_request_t, lcb_error_t);
-
-/* Prevents the callback from being invoked. This is different than a full
- * destruction of the object. This is only called in lcb_destroy() to
- * prevent dereferencing the instance itself.
- */
-void
-lcb_htreq_block_callback(lcb_http_request_t);
-#ifdef __cplusplus
-}
-#endif
-#endif
+#include "http-priv.h"