libcouchbase 0.0.1

data/ext/libcouchbase/src/hostlist.h

@@ -0,0 +1,171 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 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.
+ */
+
+#ifndef LCB_HOSTLIST_H
+#define LCB_HOSTLIST_H
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+
+/**
+ * Structure representing a host. This contains the string representation
+ * of a host and a port.
+ */
+typedef struct lcb_host_st {
+    char host[NI_MAXHOST + 1];
+    char port[NI_MAXSERV + 1];
+} lcb_host_t;
+
+/**
+ * Structure representing a list of hosts. This has an internal iteration
+ * index which is used to cycle between 'good' and 'bad' hosts.
+ */
+#ifndef __cplusplus
+struct hostlist_st;
+typedef struct hostlist_st *hostlist_t;
+#else
+#include <vector>
+
+namespace lcb {
+struct Hostlist {
+    Hostlist() : ix(0) {}
+    ~Hostlist();
+
+    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); }
+    bool exists(const lcb_host_t&) const;
+    bool exists(const char *hostport) const;
+    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);
+    void clear() { hosts.clear(); reset_strlist(); ix = 0; }
+    void randomize();
+    void ensure_strlist();
+    void reset_strlist();
+    unsigned int ix;
+    const lcb_host_t& operator[](size_t ix_) const { return hosts[ix_]; }
+
+    std::vector<lcb_host_t> hosts;
+    std::vector<const char *> hoststrs;
+};
+}
+typedef lcb::Hostlist* hostlist_t;
+#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
+ * @param spec a string to parse. This may either be an IP/host or an
+ * IP:Port pair.
+ * @param speclen the length of the string. If this is -1 then it is assumed
+ * to be NUL-terminated and strlen will be used
+ * @param deflport If a port is not found in the spec, then this port will
+ * be used
+ *
+ * @return LCB_EINVAL if the host format is invalid
+ */
+lcb_error_t
+lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport);
+
+/** Wrapper around lcb_host_parse() which accepts a NUL-terminated string
+ * @param host the host to populate
+ * @param spec a NUL-terminated string to parse
+ * @param deflport the default port to use if the `spec` does not contain a port
+ * @see lcb_host_parse()
+ */
+#define lcb_host_parsez(host, spec, deflport) lcb_host_parse(host, spec, -1, deflport)
+
+/**
+ * Compares two hosts for equality.
+ * @param a host to compare
+ * @param b other host to compare
+ * @return true if equal, false if different.
+ */
+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
+#endif

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

@@ -0,0 +1,307 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 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.
+ */
+
+#ifndef LCB_HTTPPRIV_H
+#define LCB_HTTPPRIV_H
+
+#include <libcouchbase/couchbase.h>
+#include <lcbio/lcbio.h>
+#include <lcbio/timer-ng.h>
+#include <lcbht/lcbht.h>
+#include "contrib/http_parser/http_parser.h"
+#include "http.h"
+#include <string>
+#include <vector>
+#include <set>
+
+namespace lcb {
+namespace http {
+
+// Simple object for header key and value
+struct Header {
+    std::string key;
+    std::string value;
+    Header(const std::string& key_, const std::string& value_)
+    : key(key_), value(value_) {
+    }
+};
+
+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.
+     */
+    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 */
+    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<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;
+
+    /**
+     * @return The effective timeout. This is either the user timeout or the
+     * default timeout for the API type
+     */
+    uint32_t timeout() const;
+    bool is_data_request() const {
+        return reqtype == LCB_HTTP_TYPE_N1QL ||
+                reqtype == LCB_HTTP_TYPE_VIEW ||
+                reqtype == LCB_HTTP_TYPE_FTS;
+    }
+
+    /**
+     * @return If this request is in an ONGOING state, meaning no I/O errors
+     * and is not finished.
+     */
+    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()
+     * static method creates a new object and calls this function to verify
+     * the inputs
+     */
+    inline lcb_error_t setup_inputs(const lcb_CMDHTTP* cmd);
+
+    /**
+     * Gets a target node for the destination API in the form of host:port.
+     *
+     * This function will also inspect previously used nodes and skip over ones
+     * which are problematic, in the case of retries.
+     *
+     * @param[out] rc error code
+     * @return string if there is a node, or NULL if there is an error. Check rc
+     *         for error details
+     */
+    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)
+     * @param nbase Length of the base field
+     * @param rest User input (the path)
+     * @param nrest Length of the path
+     * @return LCB_SUCCESS on success, error if failure
+     *
+     * If all parameters are 0 then this function will use the already-contained
+     * ::url field and validate/parse the inputs
+     */
+    inline lcb_error_t assign_url(const char *base, size_t nbase,
+        const char *rest, size_t nrest);
+
+    /**
+     * Helper method to get a URL field
+     * @param field The field constant (UF_XXX)
+     * @param target The string to contain the result
+     */
+    inline void assign_from_urlfield(http_parser_url_fields field,
+        std::string& target);
+
+    /**
+     * Add a new header to the list of request headers
+     * @param key header key
+     * @param value header value
+     */
+    void add_header(const std::string& key, const std::string& value) {
+        request_headers.push_back(Header(key, value));
+    }
+
+    // Helper methods to populate request buffer
+    inline void add_to_preamble(const char *);
+    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
+     * the actual connection
+     */
+    lcb_error_t start_io(lcb_host_t&);
+
+    /**
+     * Release any I/O resources attached to this request.
+     */
+    void close_io();
+
+    // 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*);
+
+    /**
+     * Called when a redirect has happened. pending_redirect must not be empty.
+     * This will transfer control to the redirect call. If there is an error
+     * during redirect, the appropriate finish() API will be called by this
+     * function.
+     *
+     * Note that the new URL should be present in the ::pending_redirect
+     * field
+     */
+    void redirect();
+
+    /**
+     * Called to initialize a response object. Sets up standard boilerplate
+     * variables for the response
+     */
+    void init_resp(lcb_RESPHTTP *resp);
+
+    /** Called by finish() to refresh the config, if necessary */
+    void maybe_refresh_config(lcb_error_t rc);
+
+    /** Finish this request, invoking the final callback if necessary */
+    void finish(lcb_error_t rc);
+
+    /**
+     * Finish or retry this request, depending on the state of the response
+     * If the request can be retried, IO will begin again, otherwise it will
+     * be finished via a call to finish()
+     **/
+    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();
+
+    /**
+     * Let the request finish its normal course, suppressing any callbacks.
+     * Unlike cancel(), this does not dispatch to finish. Finish is called
+     * when any final I/O has been completed, which may happen after the
+     * instance is already destroyed
+     */
+    void block_callback() {
+        status |= NOLCB|CBINVOKED;
+    }
+
+    /** Decrement refcount. The object is destroyed when the refcount hits 0 */
+    void decref();
+
+    /** Increment refcount */
+    void incref() { refcount++; }
+};
+
+} // namespace: http
+} // namespace: lcb
+
+struct lcb_http_request_st : public lcb::http::Request {};
+
+#endif /* HEADER GUARD */