libcouchbase 0.2.0 → 0.3.1

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

@@ -20,111 +20,60 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/views.h>
 #include "contrib/jsonsl/jsonsl.h"
-#include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"
-#include <string>
+#include "simplestring.h"
 
-namespace lcb {
-namespace jsparse {
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-struct Parser;
+typedef struct lcbvrow_PARSER_st lcbjsp_PARSER;
 
-struct Row {
-    lcb_IOV docid;
-    lcb_IOV key;
-    lcb_IOV value;
-    lcb_IOV row;
-    lcb_IOV geo;
-};
-
-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(){}
-    };
+typedef enum {
+    LCBJSP_MODE_VIEWS,
+    LCBJSP_MODE_N1QL,
+    LCBJSP_MODE_FTS
+} lcbjsp_MODE;
 
-    /**
-     * 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.
-     */
-    Parser(Mode mode, Actions* actions_);
-    ~Parser();
+typedef enum {
+    /**This is a row of view data. You can parse this as JSON from your
+     * favorite decoder/converter */
+    LCBJSP_TYPE_ROW,
 
     /**
-     * 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)
+     * 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.
      */
-    void reset();
+    LCBJSP_TYPE_COMPLETE,
 
     /**
-     * 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.
+     * 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)
      */
-    void feed(const char *s, size_t n);
-    void feed(const std::string& s) {
-        feed(s.c_str(), s.size());
-    }
+    LCBJSP_TYPE_ERROR
+} lcbjsp_ROWTYPE;
 
-    /**
-     * 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);
 
-    /**
-     * 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 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;
 
-    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);
+typedef void (*lcbjsp_CALLBACK)(lcbjsp_PARSER*,const lcbjsp_ROW*);
 
+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 */
-    std::string meta_buf; /**< String containing the skeleton (outer layer) */
-    std::string current_buf; /**< Scratch/read buffer */
-    std::string last_hk; /**< Last hashkey */
+    lcb_string meta_buf; /**< String containing the skeleton (outer layer) */
+    lcb_string current_buf; /**< Scratch/read buffer */
+    lcb_string last_hk; /**< Last hashkey */
 
     lcb_U8 mode;
 
@@ -152,15 +101,73 @@ struct Parser {
      */
     size_t last_row_endpos;
 
+    void *data;
+
     /**
      * std::string to contain parsed document ID.
      */
-    Json::Value cxx_data;
+    void *cxx_data;
 
     /* callback to invoke */
-    Actions *actions;
+    lcbjsp_CALLBACK callback;
 };
 
+/**
+ * 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.c

@@ -0,0 +1,282 @@
+/* -*- 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 "sllist-inl.h"
+#include "contrib/http_parser/http_parser.h"
+#include "settings.h"
+enum last_call_type {
+    CB_NONE,
+    CB_HDR_KEY,
+    CB_HDR_VALUE,
+    CB_HDR_DONE,
+    CB_BODY,
+    CB_MSG_DONE
+};
+
+struct lcbht_PARSER {
+    http_parser parser;
+    lcbht_RESPONSE resp; /**< Current response being processed */
+    lcb_settings *settings;
+    enum last_call_type lastcall;
+
+    /* this stuff for parse_ex() */
+    const char *last_body;
+    unsigned last_bodylen;
+    char paused;
+    char is_ex;
+};
+
+static int
+on_hdr_key(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_MIMEHDR *hdr;
+    lcbht_RESPONSE *resp = &p->resp;
+
+    if (p->lastcall != CB_HDR_KEY) {
+        /* new key */
+        hdr = calloc(1, sizeof *hdr);
+        sllist_append(&resp->headers, &hdr->slnode);
+        lcb_string_init(&hdr->buf_);
+    } else {
+        hdr = SLLIST_ITEM(resp->headers.last, lcbht_MIMEHDR, slnode);
+    }
+
+    /* append key data */
+    lcb_string_append(&hdr->buf_, s, n);
+    p->lastcall = CB_HDR_KEY;
+    return 0;
+}
+
+static int
+on_hdr_value(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_MIMEHDR *hdr;
+    lcbht_RESPONSE *resp = &p->resp;
+
+    hdr = SLLIST_ITEM(resp->headers.last, lcbht_MIMEHDR, slnode);
+    if (p->lastcall == CB_HDR_KEY) {
+        lcb_string_appendz(&hdr->buf_, ":");
+    }
+    lcb_string_append(&hdr->buf_, s, n);
+    p->lastcall = CB_HDR_VALUE;
+    return 0;
+}
+
+static int
+on_hdr_done(http_parser *pb)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    sllist_iterator iter;
+    resp->state |= LCBHT_S_HTSTATUS|LCBHT_S_HEADER;
+
+    /* extract the status */
+    resp->status = pb->status_code;
+    p->lastcall = CB_HDR_DONE;
+
+    /** Iterate through all the headers and do proper formatting */
+    SLLIST_ITERFOR(&resp->headers, &iter) {
+        char *delim;
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(iter.cur, lcbht_MIMEHDR, slnode);
+
+        delim = strstr(hdr->buf_.base, ":");
+        hdr->key = hdr->buf_.base;
+
+        if (delim) {
+            *delim = '\0';
+            hdr->value = delim + 1;
+        } else {
+            hdr->value = "";
+        }
+    }
+    return 0;
+}
+
+static int
+on_body(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    if (p->is_ex) {
+        p->last_body = s;
+        p->last_bodylen = n;
+        p->paused = 1;
+        _lcb_http_parser_pause(pb, 1);
+    } else {
+        lcb_string_append(&resp->body, s, n);
+    }
+
+    p->lastcall = CB_BODY;
+    resp->state |= LCBHT_S_BODY;
+    return 0;
+}
+
+static int
+on_msg_done(http_parser *pb)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    resp->state |= LCBHT_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
+};
+
+lcbht_pPARSER
+lcbht_new(lcb_settings *settings)
+{
+    lcbht_pPARSER ret = calloc(1, sizeof *ret);
+    lcbht_reset(ret);
+    ret->settings = settings;
+    lcb_settings_ref(settings);
+    return ret;
+}
+
+void
+lcbht_free(lcbht_pPARSER parser)
+{
+    lcbht_clear_response(&parser->resp);
+    lcb_settings_unref(parser->settings);
+    free(parser);
+}
+
+lcbht_RESPSTATE
+lcbht_parse(lcbht_pPARSER parser, const void *data, unsigned ndata)
+{
+    size_t nb;
+    parser->is_ex = 0;
+    nb = _lcb_http_parser_execute(&parser->parser, &Parser_Settings, data, ndata);
+    if (nb != ndata) {
+        parser->resp.state |= LCBHT_S_ERROR;
+    }
+    return parser->resp.state;
+}
+
+lcbht_RESPSTATE
+lcbht_parse_ex(lcbht_pPARSER parser, const void *data, unsigned ndata,
+    unsigned *nused, unsigned *nbody, const char **pbody)
+{
+    size_t nb;
+    parser->is_ex = 1;
+    nb = _lcb_http_parser_execute(&parser->parser, &Parser_Settings, data, ndata);
+    if (nb != ndata) {
+        if (parser->paused) {
+            _lcb_http_parser_pause(&parser->parser, 0);
+            parser->paused = 0;
+        } else {
+            parser->resp.state |= LCBHT_S_ERROR;
+            return parser->resp.state;
+        }
+    }
+
+    *nused = nb;
+    *nbody = parser->last_bodylen;
+    *pbody = parser->last_body;
+
+    parser->last_body = NULL;
+    parser->last_bodylen = 0;
+    return parser->resp.state;
+}
+
+lcbht_RESPONSE *
+lcbht_get_response(lcbht_pPARSER parser)
+{
+    return &parser->resp;
+}
+
+int
+lcbht_can_keepalive(lcbht_pPARSER parser)
+{
+    if (!(parser->resp.state & LCBHT_S_DONE)) {
+        return 0;
+    }
+
+    if (parser->resp.state & LCBHT_S_ERROR) {
+        return 0;
+    }
+
+    return _lcb_http_should_keep_alive(&parser->parser);
+}
+
+void
+lcbht_clear_response(lcbht_RESPONSE *resp)
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&resp->headers, &iter) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(iter.cur, lcbht_MIMEHDR, slnode);
+        lcb_string_release(&hdr->buf_);
+        sllist_iter_remove(&resp->headers, &iter);
+        free(hdr);
+    }
+    lcb_string_release(&resp->body);
+    resp->state = 0;
+    resp->status = 0;
+}
+
+void
+lcbht_reset(lcbht_pPARSER parser)
+{
+    lcbht_clear_response(&parser->resp);
+    _lcb_http_parser_init(&parser->parser, HTTP_RESPONSE);
+}
+
+const char *
+lcbht_get_resphdr(const lcbht_RESPONSE *resp, const char *key)
+{
+    sllist_node *curnode;
+    SLLIST_ITERBASIC(&resp->headers, curnode) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
+        if (!strcmp(hdr->key, key)) {
+            return hdr->value;
+        }
+    }
+    return NULL;
+}
+
+char **
+lcbht_make_resphdrlist(lcbht_RESPONSE *response)
+{
+    char **ret;
+    unsigned nhdrs = 0;
+    unsigned curix = 0;
+    sllist_node *curnode;
+    SLLIST_ITERBASIC(&response->headers, curnode) {
+        nhdrs++;
+    }
+    ret = malloc(sizeof(*ret) * (nhdrs + 1) * 2);
+
+    SLLIST_ITERBASIC(&response->headers, curnode) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
+        ret[curix++] = strdup(hdr->key);
+        ret[curix++] = strdup(hdr->value);
+    }
+
+    ret[curix] = NULL;
+    return ret;
+}