libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/jsparse/parser.h

@@ -20,60 +20,104 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/views.h>
 #include "contrib/jsonsl/jsonsl.h"
-#include "simplestring.h"
+#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
+#include <string>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+namespace lcb {
+namespace jsparse {
 
-typedef struct lcbvrow_PARSER_st lcbjsp_PARSER;
+struct Parser;
 
-typedef enum {
-    LCBJSP_MODE_VIEWS,
-    LCBJSP_MODE_N1QL,
-    LCBJSP_MODE_FTS
-} lcbjsp_MODE;
+struct Row {
+    lcb_IOV docid;
+    lcb_IOV key;
+    lcb_IOV value;
+    lcb_IOV row;
+    lcb_IOV geo;
+};
 
-typedef enum {
-    /**This is a row of view data. You can parse this as JSON from your
-     * favorite decoder/converter */
-    LCBJSP_TYPE_ROW,
+struct Parser {
+    enum Mode {
+        MODE_VIEWS,
+        MODE_N1QL,
+        MODE_FTS
+    };
+
+    struct Actions {
+        /**
+         * Called when a row is received.
+         * This is a row of view data. You can parse this as JSON from your
+         * favorite decoder/converter
+         */
+        virtual void JSPARSE_on_row(const Row&) = 0;
+
+        /**
+         * A JSON parse error occured. The payload will contain string data. This
+         * may be JSON (but this is not likely).
+         * The callback will be delivered twice. First when the error is noticed,
+         * and second at the end (instead of a COMPLETE callback)
+         */
+        virtual void JSPARSE_on_error(const std::string& buf) = 0;
+
+        /**
+         * All the rows have been returned. In this case, the data is the 'meta'.
+         * This is a valid JSON payload which was returned from the server.
+         * The "rows" : [] array will be empty.
+         */
+        virtual void JSPARSE_on_complete(const std::string& meta) = 0;
+
+        virtual ~Actions(){}
+    };
 
     /**
-     * All the rows have been returned. In this case, the data is the 'meta'.
-     * This is a valid JSON payload which was returned from the server.
-     * The "rows" : [] array will be empty.
+     * Creates a new vrow context object.
+     * You must set callbacks on this object if you wish it to be useful.
+     * You must feed it data (calling vrow_feed) as well. The data may be fed
+     * in chunks and callbacks will be invoked as each row is read.
      */
-    LCBJSP_TYPE_COMPLETE,
+    Parser(Mode mode, Actions* actions_);
+    ~Parser();
 
     /**
-     * A JSON parse error occured. The payload will contain string data. This
-     * may be JSON (but this is not likely).
-     * The callback will be delivered twice. First when the error is noticed,
-     * and second at the end (instead of a COMPLETE callback)
+     * Feeds data into the vrow. The callback may be invoked multiple times
+     * in this function. In the context of normal lcb usage, this will typically
+     * be invoked from within an http_data_callback.
      */
-    LCBJSP_TYPE_ERROR
-} lcbjsp_ROWTYPE;
+    void feed(const char *s, size_t n);
+    void feed(const std::string& s) {
+        feed(s.c_str(), s.size());
+    }
 
+    /**
+     * Parse the row buffer into its constituent parts. This should be called
+     * if you want to split the row into its basic 'docid', 'key' and 'value'
+     * fields
+     * @param vp The parser to use
+     * @param vr The row to parse. This assumes the row's "row" field is properly
+     * set.
+     */
+    void parse_viewrow(Row& vr);
 
-typedef struct {
-    lcbjsp_ROWTYPE type; /**< The type of data encapsulated */
-    lcb_IOV docid;
-    lcb_IOV key;
-    lcb_IOV value;
-    lcb_IOV row;
-    lcb_IOV geo;
-} lcbjsp_ROW;
+    /**
+     * Get the raw contents of the current buffer. This can be used to debug errors.
+     *
+     * Note that the buffer may be partial or malformed or otherwise unsuitable
+     * for structured inspection, but may help human observers debug problems.
+     *
+     * @param out The iov structure to contain the buffer/offset
+     */
+    void get_postmortem(lcb_IOV& out) const;
 
-typedef void (*lcbjsp_CALLBACK)(lcbjsp_PARSER*,const lcbjsp_ROW*);
+    inline const char *get_buffer_region(size_t pos, size_t desired, size_t* actual);
+    inline void combine_meta();
+    inline static const char *jprstr_for_mode(Mode);
 
-struct lcbvrow_PARSER_st {
     jsonsl_t jsn; /**< Parser for the row itself */
     jsonsl_t jsn_rdetails; /**< Parser for the row details */
     jsonsl_jpr_t jpr; /**< jsonpointer match object */
-    lcb_string meta_buf; /**< String containing the skeleton (outer layer) */
-    lcb_string current_buf; /**< Scratch/read buffer */
-    lcb_string last_hk; /**< Last hashkey */
+    std::string meta_buf; /**< String containing the skeleton (outer layer) */
+    std::string current_buf; /**< Scratch/read buffer */
+    std::string last_hk; /**< Last hashkey */
 
     lcb_U8 mode;
 
@@ -101,73 +145,15 @@ struct lcbvrow_PARSER_st {
      */
     size_t last_row_endpos;
 
-    void *data;
-
     /**
      * std::string to contain parsed document ID.
      */
-    void *cxx_data;
+    Json::Value cxx_data;
 
     /* callback to invoke */
-    lcbjsp_CALLBACK callback;
+    Actions *actions;
 };
 
-/**
- * Creates a new vrow context object.
- * You must set callbacks on this object if you wish it to be useful.
- * You must feed it data (calling vrow_feed) as well. The data may be fed
- * in chunks and callbacks will be invoked as each row is read.
- */
-lcbjsp_PARSER*
-lcbjsp_create(int);
-
-/**
- * Resets the context to a pristine state. Callbacks and cookies are kept.
- * This may be more efficient than allocating/freeing a context each time
- * (as this can be expensive with the jsonsl structures)
- */
-void
-lcbjsp_reset(lcbjsp_PARSER *ctx);
-
-/**
- * Frees a vrow object created by vrow_create
- */
-void
-lcbjsp_free(lcbjsp_PARSER *ctx);
-
-/**
- * Feeds data into the vrow. The callback may be invoked multiple times
- * in this function. In the context of normal lcb usage, this will typically
- * be invoked from within an http_data_callback.
- */
-void
-lcbjsp_feed(lcbjsp_PARSER *ctx, const char *data, size_t ndata);
-
-/**
- * Parse the row buffer into its constituent parts. This should be called
- * if you want to split the row into its basic 'docid', 'key' and 'value'
- * fields
- * @param vp The parser to use
- * @param vr The row to parse. This assumes the row's "row" field is properly
- * set.
- */
-void
-lcbjsp_parse_viewrow(lcbjsp_PARSER *vp, lcbjsp_ROW *vr);
-
-/**
- * Get the raw contents of the current buffer. This can be used to debug errors.
- *
- * Note that the buffer may be partial or malformed or otherwise unsuitable
- * for structured inspection, but may help human observers debug problems.
- *
- * @param v The parser
- * @param out The iov structure to contain the buffer/offset
- */
-void
-lcbjsp_get_postmortem(const lcbjsp_PARSER *v, lcb_IOV *out);
-
-#ifdef __cplusplus
 }
-#endif
-
+}
 #endif /* LCB_VIEWROW_H_ */

data/ext/libcouchbase/src/lcbht/lcbht.cc

@@ -0,0 +1,177 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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.
+ */
+
+#include "lcbht.h"
+#include "contrib/http_parser/http_parser.h"
+#include "settings.h"
+
+using namespace lcb::htparse;
+
+
+Parser::Parser(lcb_settings_st *settings_)
+    : http_parser(), settings(settings_), lastcall(CB_NONE),
+      last_body(0), last_bodylen(0), paused(false), is_ex(false) {
+    lcb_settings_ref(settings);
+    reset();
+}
+
+Parser::~Parser() {
+    lcb_settings_unref(settings);
+}
+
+static int on_hdr_key(http_parser *pb, const char *s, size_t n) {
+    return Parser::from_htp(pb)->on_hdr_key(s, n);
+}
+int Parser::on_hdr_key(const char *s, size_t n) {
+    if (lastcall != CB_HDR_KEY) {
+        /* new key */
+        resp.headers.push_back(MimeHeader());
+    }
+
+    resp.headers.back().key.append(s, n);
+    lastcall = CB_HDR_KEY;
+    return 0;
+}
+
+static int on_hdr_value(http_parser *pb, const char *s, size_t n) {
+    return Parser::from_htp(pb)->on_hdr_value(s, n);
+}
+
+int Parser::on_hdr_value(const char *s, size_t n) {
+    MimeHeader *header = &resp.headers.back();
+    header->value.append(s, n);
+    lastcall = CB_HDR_VALUE;
+    return 0;
+}
+
+static int on_hdr_done(http_parser *pb) {
+    return Parser::from_htp(pb)->on_hdr_done();
+}
+int Parser::on_hdr_done() {
+    resp.state |= S_HTSTATUS|S_HEADER;
+
+    /* extract the status */
+    resp.status = http_parser::status_code;
+    lastcall = CB_HDR_DONE;
+    return 0;
+}
+
+static int on_body(http_parser *pb, const char *s, size_t n) {
+    return Parser::from_htp(pb)->on_body(s, n);
+}
+int Parser::on_body(const char *s, size_t n) {
+    if (is_ex) {
+        last_body = s;
+        last_bodylen = n;
+        paused = true;
+        _lcb_http_parser_pause(this, 1);
+    } else {
+        resp.body.append(s, n);
+    }
+
+    lastcall = CB_BODY;
+    resp.state |= S_BODY;
+    return 0;
+}
+
+static int on_msg_done(http_parser *pb) {
+    return Parser::from_htp(pb)->on_msg_done();
+}
+
+int Parser::on_msg_done() {
+    resp.state |= S_DONE;
+    return 0;
+}
+
+
+static struct http_parser_settings Parser_Settings = {
+        NULL, /* msg_begin */
+        NULL, /* on_url */
+        ::on_hdr_key,
+        ::on_hdr_value,
+        ::on_hdr_done,
+        ::on_body,
+        ::on_msg_done
+};
+
+unsigned
+Parser::parse(const void *data_, size_t ndata) {
+    is_ex = false;
+    size_t nb = _lcb_http_parser_execute(this,
+        &Parser_Settings,
+        reinterpret_cast<const char *>(data_), ndata);
+
+    if (nb != ndata) {
+        resp.state |= S_ERROR;
+    }
+
+    return resp.state;
+}
+
+unsigned
+Parser::parse_ex(const void *data_, unsigned ndata,
+    unsigned *nused, unsigned *nbody, const char **pbody)
+{
+    is_ex = true;
+    size_t nb = _lcb_http_parser_execute(this,
+            &Parser_Settings, reinterpret_cast<const char*>(data_), ndata);
+    if (nb != ndata) {
+        if (paused) {
+            _lcb_http_parser_pause(this, 0);
+            paused = false;
+        } else {
+            resp.state |= S_ERROR;
+            return resp.state;
+        }
+    }
+
+    *nused = nb;
+    *nbody = last_bodylen;
+    *pbody = last_body;
+
+    last_body = NULL;
+    last_bodylen = 0;
+    return resp.state;
+}
+
+bool Parser::can_keepalive() const {
+    if (!(resp.state & S_DONE)) {
+        return 0;
+    }
+
+    if (resp.state & S_ERROR) {
+        return 0;
+    }
+
+    return _lcb_http_should_keep_alive(
+        const_cast<http_parser*>(static_cast<const http_parser*>(this)));
+}
+
+void Parser::reset() {
+    resp.clear();
+    _lcb_http_parser_init(this, HTTP_RESPONSE);
+}
+
+const MimeHeader* Response::get_header(const std::string& key) const {
+    std::list<MimeHeader>::const_iterator it;
+    for (it = headers.begin(); it != headers.end(); ++it) {
+        if (it->key == key) {
+            return &*it;
+        }
+    }
+    return NULL;
+}

data/ext/libcouchbase/src/lcbht/lcbht.h

@@ -19,14 +19,11 @@
 #define LCB_HTTP_H
 
 #include <libcouchbase/couchbase.h>
-#include "simplestring.h"
-#include "sllist.h"
-struct lcb_settings_st;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include "contrib/http_parser/http_parser.h"
+#include <list>
+#include <string>
 
+struct lcb_settings_st;
 
 /**
  * @file
@@ -39,161 +36,175 @@ extern "C" {
  * body.
  */
 
-/** Response state */
-typedef enum {
-    LCBHT_S_HTSTATUS = 1 << 0, /**< Have HTTP status */
-    LCBHT_S_HEADER = 1 << 1, /**< Have HTTP header */
-    LCBHT_S_BODY = 1 << 2, /**< Have HTTP body */
-    LCBHT_S_DONE = 1 << 3, /**< Have a full message */
-
-    /**Have a parse error. Note this is not the same as a HTTP error */
-    LCBHT_S_ERROR = 1 << 4
-} lcbht_RESPSTATE;
-
-typedef struct {
-    sllist_node slnode; /**< Next header in list */
-    const char *key;
-    const char *value;
-    lcb_string buf_; /**< Storage for the key and value */
-} lcbht_MIMEHDR;
-
-typedef struct {
-    unsigned short status; /**< HTTP Status code */
-    lcbht_RESPSTATE state;
-    sllist_root headers; /**< List of response headers */
-    lcb_string body; /**< Body */
-} lcbht_RESPONSE;
-
-typedef struct lcbht_PARSER *lcbht_pPARSER;
-
-/**
- * Initialize the parser object
- * @param settings the settings structure used for logging
- * @return a new parser object
- */
-lcbht_pPARSER
-lcbht_new(struct lcb_settings_st *settings);
-
-/** Free the parser object */
-void
-lcbht_free(lcbht_pPARSER);
-
-void
-lcbht_reset(lcbht_pPARSER);
-
-/**
- * Parse incoming data into a message
- * @param parser The parser
- * @param data Pointer to new data
- * @param ndata Size of the data
- *
- * @return The current state of the parser. If `state & LCBHT_S_DONE` then
- * the current response should be handled before continuing.
- * If `state & LCBHT_S_ERROR` then there was an error parsing the contents
- * as it violated the HTTP protocol.
- */
-lcbht_RESPSTATE
-lcbht_parse(lcbht_pPARSER parser, const void *data, unsigned ndata);
-
-/**
- * Parse incoming data without buffering
- * @param parser The parser to use
- * @param data The data to parse
- * @param ndata Length of the data
- * @param[out] nused How much of the data was actually consumed
- * @param[out] nbody Size of the body pointer
- * @param[out] pbody a pointer for the body
- *
- * @return See lcbht_set_bufmode for the meaning of this value
- *
- * @note It is not an error if `pbody` is NULL. It may mean that the parse state
- * is still within the headers and there is no body to parse yet.
- *
- * This function is intended to be used in a loop, until there is no input
- * remaining. The use of the `nused` pointer is to determine by how much the
- * `data` pointer should be incremented (and the `ndata` decremented) for the
- * next call. When this function returns with a non-error status, `pbody`
- * will contain a pointer to a buffer of data (but see note above) which can
- * then be processed by the application.
- *
- * @code{.c}
- * char **body, *input;
- * unsigned inlen = get_input_len(), nused, bodylen;
- * lcbht_RESPSTATE res;
- * do {
- *   res = lcbht_parse_ex(parser, input, inlen, &nused, &nbody, &body);
- *   if (res & LCBHT_S_ERROR) {
- *     // handle error
- *     break;
- *   }
- *   if (nbody) {
- *     // handle body
- *   }
- *   input += nused;
- *   inlen -= nused;
- * } while (!(res & LCBHT_S_DONE));
- * @endcode
- */
-lcbht_RESPSTATE
-lcbht_parse_ex(lcbht_pPARSER parser, const void *data, unsigned ndata,
-    unsigned *nused, unsigned *nbody, const char **pbody);
-
-
-/**
- * Obtain the current response being processed.
- * @param parser The parser
- * @return a pointer to a response object. The response object is only valid
- * until the next call into another parser API
- */
-lcbht_RESPONSE *
-lcbht_get_response(lcbht_pPARSER parser);
-
-/**
- * Determine whether HTTP/1.1 keepalive is enabled on the connection
- * @param parser The parser
- * @return true if keepalive is enabled, false otherwise.
- */
-int
-lcbht_can_keepalive(lcbht_pPARSER parser);
-
-/**
- * Clear the response object
- * @param resp the response to clear
- */
-void
-lcbht_clear_response(lcbht_RESPONSE *resp);
-
-/**
- * Get a header value for a key
- * @param response The response
- * @param key The key to look up
- * @return A string containing the value. If the header has no value then the
- * empty string will be returned. If the header does not exist NULL will be
- * returned.
- */
-const char *
-lcbht_get_resphdr(const lcbht_RESPONSE *response, const char *key);
+namespace lcb {
+namespace htparse {
+
+
+struct MimeHeader {
+    std::string key;
+    std::string value;
+};
+
+struct Response {
+    void clear() {
+        status = 0;
+        state = 0;
+        headers.clear();
+        body.clear();
+    }
+
+    /**
+     * Get a header value for a key
+     * @param response The response
+     * @param key The key to look up
+     * @return A string containing the value. If the header has no value then the
+     * empty string will be returned. If the header does not exist NULL will be
+     * returned.
+     */
+    const MimeHeader* get_header(const std::string& key) const;
+
+    /**
+     * Get a header value for a key
+     * @param key The key to look up
+     * @return A string containing the value. If the header has no value then the
+     * empty string will be returned. If the header does not exist NULL will be
+     * returned.
+     */
+    const char *get_header_value(const std::string& key) const {
+        const MimeHeader *header = get_header(key);
+        if (header) {
+            return header->value.c_str();
+        }
+        return NULL;
+    }
 
-/**
- * Return a list of headers
- * @param response The response
- * @return A list of headers. Iterate over this value like so:
- * @code{.c}
- * char **hdrlist = lcbht_make_resphdrlist(response);
- * for (char **cur = hdrlist; *cur; cur += 2) {
- *      char *key = cur[0];
- *      char *value = cur[1];
- *      // do something
- *      free(key);
- *      free(value);
- * }
- * free(hdrlist);
- * @endcode
- */
-char **
-lcbht_make_resphdrlist(lcbht_RESPONSE *response);
-
-#ifdef __cplusplus
-}
-#endif
+    unsigned short status; /**< HTTP Status code */
+    unsigned state;
+    typedef std::list<MimeHeader> HeaderList;
+    HeaderList headers;
+    std::string body; /**< Body */
+};
+
+class Parser : private http_parser {
+public:
+    /**
+     * Initialize the parser object
+     * @param settings the settings structure used for logging
+     */
+    Parser(lcb_settings_st*);
+    ~Parser();
+
+    /** Response state */
+    enum State {
+        S_NONE = 0,
+        S_HTSTATUS = 1 << 0, /**< Have HTTP status */
+        S_HEADER = 1 << 1, /**< Have HTTP header */
+        S_BODY = 1 << 2, /**< Have HTTP body */
+        S_DONE = 1 << 3, /**< Have a full message */
+
+        /**Have a parse error. Note this is not the same as a HTTP error */
+        S_ERROR = 1 << 4
+    };
+
+    /**
+     * Parse incoming data into a message
+     * @param data Pointer to new data
+     * @param ndata Size of the data
+     *
+     * @return The current state of the parser. If `state & LCBHT_S_DONE` then
+     * the current response should be handled before continuing.
+     * If `state & LCBHT_S_ERROR` then there was an error parsing the contents
+     * as it violated the HTTP protocol.
+     */
+    unsigned parse(const void *data, size_t ndata);
+
+    /**
+     * Parse incoming data without buffering
+     * @param data The data to parse
+     * @param ndata Length of the data
+     * @param[out] nused How much of the data was actually consumed
+     * @param[out] nbody Size of the body pointer
+     * @param[out] pbody a pointer for the body
+     *
+     * @return See lcbht_set_bufmode for the meaning of this value
+     *
+     * @note It is not an error if `pbody` is NULL. It may mean that the parse state
+     * is still within the headers and there is no body to parse yet.
+     *
+     * This function is intended to be used in a loop, until there is no input
+     * remaining. The use of the `nused` pointer is to determine by how much the
+     * `data` pointer should be incremented (and the `ndata` decremented) for the
+     * next call. When this function returns with a non-error status, `pbody`
+     * will contain a pointer to a buffer of data (but see note above) which can
+     * then be processed by the application.
+     *
+     * @code{.c++}
+     * char **body, *input;
+     * unsigned inlen = get_input_len(), nused, bodylen;
+     * unsigned res;
+     * do {
+     *   res = parser->parse_ex(input, inlen, &nused, &nbody, &body);
+     *   if (res & Parser::S_ERROR) {
+     *     // handle error
+     *     break;
+     *   }
+     *   if (nbody) {
+     *     // handle body
+     *   }
+     *   input += nused;
+     *   inlen -= nused;
+     * } while (!(res & Parser::S_DONE));
+     * @endcode
+     */
+    unsigned parse_ex(const void *data, unsigned ndata,
+                      unsigned* nused, unsigned *nbody, const char **pbody);
+
+    /**
+     * Obtain the current response being processed.
+     * @return a reference to a response object. The response object is only valid
+     * until the next call into another parser API
+     */
+    Response& get_cur_response() {
+        return resp;
+    }
+
+    /**
+     * Determine whether HTTP/1.1 keepalive is enabled on the connection
+     * @return true if keepalive is enabled, false otherwise.
+     */
+    bool can_keepalive() const;
+
+    void reset();
+
+    // Callbacks:
+    inline int on_hdr_key(const char *, size_t);
+    inline int on_hdr_value(const char *, size_t);
+    inline int on_hdr_done();
+    inline int on_body(const char *, size_t);
+    inline int on_msg_done();
+
+    static Parser* from_htp(http_parser *p) {
+        return static_cast<Parser*>(p);
+    }
+
+private:
+    Response resp;
+    lcb_settings_st *settings;
+
+    enum last_call_type {
+        CB_NONE, CB_HDR_KEY, CB_HDR_VALUE,
+        CB_HDR_DONE, CB_BODY, CB_MSG_DONE
+    };
+    last_call_type lastcall;
+
+    /* For parse_ex */
+    const char *last_body;
+    unsigned last_bodylen;
+
+    bool paused;
+    bool is_ex;
+};
+
+} // namespace htparse
+} // namespace lcb
 #endif