libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/lcbio/connect.h

@@ -23,9 +23,24 @@
 #include "settings.h"
 #include "hostlist.h"
 #ifdef __cplusplus
+namespace lcb {
+namespace io {
+struct Connstart;
+struct PoolRequest;
+class ConnectionRequest;
+}
+}
+typedef lcb::io::ConnectionRequest* lcbio_pCONNSTART;
+typedef lcb::io::ConnectionRequest lcbio_MGRREQ;
 extern "C" {
+#else
+struct lcbio_CONNSTART;
+typedef struct lcbio_CONNSTART* lcbio_pCONNSTART;
+typedef struct lcbio_MGRREQ lcbio_MGRREQ;
 #endif
 
+typedef lcbio_MGRREQ* lcbio_pMGRREQ;
+
 /**
  * @file
  * This provides the core socket routines
@@ -39,12 +54,6 @@ extern "C" {
  * @{
  */
 
-struct lcbio_CONNSTART;
-struct lcbio_MGRREQ;
-
-/** @brief Pending connection request */
-typedef struct lcbio_CONNSTART *lcbio_pCONNSTART;
-typedef struct lcbio_MGRREQ *lcbio_pMGRREQ;
 typedef struct lcbio_TABLE *lcbio_pTABLE;
 typedef struct lcbio_TIMER *lcbio_pTIMER, *lcbio_pASYNC;
 
@@ -266,7 +275,7 @@ lcbio_protoctx_add(lcbio_SOCKET *socket, lcbio_PROTOCTX *proto);
  * @return the context, or NULL if not found
  */
 lcbio_PROTOCTX *
-lcbio_protoctx_get(lcbio_SOCKET *socket, lcbio_PROTOID id);
+lcbio_protoctx_get(const lcbio_SOCKET *socket, lcbio_PROTOID id);
 
 /**
  * Remove a protocol context by its ID

data/ext/libcouchbase/src/lcbio/ctx.c

@@ -148,7 +148,7 @@ lcbio_ctx_close_ex(lcbio_CTX *ctx, lcbio_CTXCLOSE_cb cb, void *arg,
     }
 
     oldrc = ctx->sock->refcount;
-    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying. PND=%d,ENT=%d,SORC=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered, oldrc);
+    lcb_log(LOGARGS(ctx, DEBUG), CTX_LOGFMT "Destroying context. Pending Writes=%d, Entered=%s, Socket Refcount=%d", CTX_LOGID(ctx), (int)ctx->npending, (int)ctx->entered ? "true": "false", oldrc);
 
     if (cb) {
         int reusable =

data/ext/libcouchbase/src/lcbio/iotable.h

@@ -37,22 +37,6 @@
 extern "C" {
 #endif
 
-typedef struct lcbio_TABLE {
-    lcb_io_opt_t p;
-    lcb_iomodel_t model;
-    lcb_timer_procs timer;
-    lcb_loop_procs loop;
-
-    union {
-        struct {
-            lcb_ev_procs ev;
-            lcb_bsd_procs io;
-        } v0;
-        lcb_completion_procs completion;
-    } u_io;
-    unsigned refcount;
-    void (*dtor)(void *);
-} lcbio_TABLE;
 
 /** Whether the underlying model is event-based */
 #define IOT_IS_EVENT(iot) ((iot)->model == LCB_IOMODEL_EVENT)
@@ -78,6 +62,107 @@ typedef struct lcbio_TABLE {
 /** First argument to IO Table */
 #define IOT_ARG(iot) (iot)->p
 
+typedef struct lcbio_TABLE {
+    lcb_io_opt_t p;
+    lcb_iomodel_t model;
+    lcb_timer_procs timer;
+    lcb_loop_procs loop;
+
+    union {
+        struct {
+            lcb_ev_procs ev;
+            lcb_bsd_procs io;
+        } v0;
+        lcb_completion_procs completion;
+    } u_io;
+    unsigned refcount;
+    void (*dtor)(void *);
+
+#ifdef __cplusplus
+    bool is_E() const { return IOT_IS_EVENT(this); }
+    bool is_C() const { return !is_E(); }
+    int get_errno() const { return IOT_ERRNO(this); }
+
+    void run_loop() { IOT_START(this); }
+    void stop_loop() { IOT_STOP(this); }
+
+    int E_connect(lcb_socket_t sock, const sockaddr* saddr, unsigned addrlen) {
+       return IOT_V0IO(this).connect0(p, sock, saddr, addrlen);
+    }
+
+    lcb_socket_t E_socket(int domain, int type, int protocol) {
+        return IOT_V0IO(this).socket0(p, domain, type, protocol);
+    }
+
+    lcb_socket_t E_socket(const addrinfo *ai) {
+        return E_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+    }
+
+    void E_close(lcb_socket_t sock) {
+        IOT_V0IO(this).close(p, sock);
+    }
+
+    void *E_event_create() {
+        return IOT_V0EV(this).create(p);
+    }
+
+    void E_event_watch(lcb_socket_t fd, void *event, short mask, void *arg,
+                       lcb_ioE_callback cb) {
+        IOT_V0EV(this).watch(p, fd, event, mask, arg, cb);
+    }
+
+     void E_event_destroy(void *event) {
+         IOT_V0EV(this).destroy(p, event);
+     }
+
+    void E_event_cancel(lcb_socket_t fd, void *event) {
+        IOT_V0EV(this).cancel(p, fd, event);
+    }
+
+    int E_check_closed(lcb_socket_t s, int flags) {
+        return IOT_V0IO(this).is_closed(p, s, flags);
+    }
+
+    int E_cntl(lcb_socket_t s, int mode, int opt, void *val) {
+        return IOT_V0IO(this).cntl(p, s, mode, opt, val);
+    }
+
+    void C_close(lcb_sockdata_t *sd) {
+        IOT_V1(this).close(p, sd);
+    }
+
+    int C_connect(lcb_sockdata_t *sd, const sockaddr *addr, unsigned addrlen,
+                  lcb_io_connect_cb callback) {
+        return IOT_V1(this).connect(p, sd, addr, addrlen, callback);
+    }
+
+    lcb_sockdata_t* C_socket(int domain, int type, int protocol) {
+        return IOT_V1(this).socket(p, domain, type, protocol);
+    }
+
+    lcb_sockdata_t* C_socket(const addrinfo *ai) {
+        return C_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+    }
+
+    int C_check_closed(lcb_sockdata_t *sock, int flags) {
+        return IOT_V1(this).is_closed(p, sock, flags);
+    }
+
+    int C_cntl(lcb_sockdata_t *sd, int mode, int opt, void *val) {
+        return IOT_V1(this).cntl(p, sd, mode, opt, val) == 0;
+    }
+
+    bool has_cntl() {
+        if (is_E()) {
+            return IOT_V0IO(this).cntl != NULL;
+        } else {
+            return IOT_V1(this).cntl != NULL;
+        }
+    }
+#endif
+
+} lcbio_TABLE;
+
 #ifdef __cplusplus
 }
 #endif

data/ext/libcouchbase/src/lcbio/{ioutils.c → ioutils.cc}

@@ -100,7 +100,7 @@ ioerr2lcberr(lcbio_OSERR in, const lcb_settings *settings)
     case ECONNABORTED:
         return LCB_ECONNRESET;
     default:
-        lcb_log(settings, "lcbio", LCB_LOG_WARN, __FILE__, __LINE__, "FIXME: Unknown iops/os error code %d. Using NETWORK_ERROR", in);
+        lcb_log(settings, "lcbio", LCB_LOG_WARN, __FILE__, __LINE__, "OS errno %d (%s) does not have a direct client error code equivalent. Using NETWORK_ERROR", in, strerror(in));
         return LCB_NETWORK_ERROR;
     }
 }
@@ -124,14 +124,12 @@ lcbio_E_ai2sock(lcbio_TABLE *io, struct addrinfo **ai, int *connerr)
     *connerr = 0;
 
     for (; *ai; *ai = (*ai)->ai_next) {
-        ret = IOT_V0IO(io).socket0(
-                IOT_ARG(io), (*ai)->ai_family, (*ai)->ai_socktype,
-                (*ai)->ai_protocol);
+        ret = io->E_socket(*ai);
 
         if (ret != INVALID_SOCKET) {
             return ret;
         } else {
-            *connerr = IOT_ERRNO(io);
+            *connerr = io->get_errno();
         }
     }
 
@@ -143,9 +141,7 @@ lcbio_C_ai2sock(lcbio_TABLE *io, struct addrinfo **ai, int *connerr)
 {
     lcb_sockdata_t *ret = NULL;
     for (; *ai; *ai = (*ai)->ai_next) {
-        ret = IOT_V1(io).socket(
-                IOT_ARG(io), (*ai)->ai_family, (*ai)->ai_socktype,
-                (*ai)->ai_protocol);
+        ret = io->C_socket(*ai);
         if (ret) {
             return ret;
         } else {
@@ -254,31 +250,26 @@ lcbio_is_netclosed(lcbio_SOCKET *sock, int flags)
 {
     lcbio_pTABLE iot = sock->io;
 
-    if (IOT_IS_EVENT(iot)) {
-        return IOT_V0IO(iot).is_closed(IOT_ARG(iot), sock->u.fd, flags);
+    if (iot->is_E()) {
+        return iot->E_check_closed(sock->u.fd, flags);
     } else {
-        return IOT_V1(iot).is_closed(IOT_ARG(iot), sock->u.sd, flags);
+        return iot->C_check_closed(sock->u.sd, flags);
     }
 }
 
 lcb_error_t
-lcbio_disable_nagle(lcbio_SOCKET *s)
-{
+lcbio_enable_sockopt(lcbio_SOCKET *s, int cntl) {
     lcbio_pTABLE iot = s->io;
-    int val = 1, rv;
-    int is_supp = ((IOT_IS_EVENT(iot) && IOT_V0IO(iot).cntl)) ||
-            (!IOT_IS_EVENT(iot) && IOT_V1(iot).cntl);
+    int rv;
+    int value = 1;
 
-    if (!is_supp) {
+    if (!iot->has_cntl()) {
         return LCB_NOT_SUPPORTED;
     }
-
-    if (IOT_IS_EVENT(iot)) {
-        rv = IOT_V0IO(iot).cntl(IOT_ARG(iot), s->u.fd, LCB_IO_CNTL_SET,
-            LCB_IO_CNTL_TCP_NODELAY, &val);
+    if (iot->is_E()) {
+        rv = iot->E_cntl(s->u.fd, LCB_IO_CNTL_SET, cntl, &value);
     } else {
-        rv = IOT_V1(iot).cntl(IOT_ARG(iot), s->u.sd, LCB_IO_CNTL_SET,
-            LCB_IO_CNTL_TCP_NODELAY, &val);
+        rv = iot->C_cntl(s->u.sd, LCB_IO_CNTL_SET, cntl, &value);
     }
     if (rv != 0) {
         return lcbio_mklcberr(IOT_ERRNO(iot), s->settings);
@@ -287,22 +278,16 @@ lcbio_disable_nagle(lcbio_SOCKET *s)
     }
 }
 
-void
-lcbio_connreq_cancel(lcbio_CONNREQ *req)
-{
-    if (!req->u.cs) {
-        return;
-    }
-
-    if (req->type == LCBIO_CONNREQ_POOLED) {
-        lcbio_mgr_cancel(req->u.preq);
-    } else if (req->type == LCBIO_CONNREQ_RAW) {
-        lcbio_connect_cancel(req->u.cs);
-    } else {
-        req->dtor(req->u.p_generic);
+const char *
+lcbio_strsockopt(int cntl) {
+    switch (cntl) {
+    case LCB_IO_CNTL_TCP_KEEPALIVE:
+        return "TCP_KEEPALIVE";
+    case LCB_IO_CNTL_TCP_NODELAY:
+        return "TCP_NODELAY";
+    default:
+        return "FIXME: Unknown option";
     }
-
-    req->u.cs = NULL;
 }
 
 int
@@ -316,35 +301,29 @@ lcbio_ssl_supported(void)
 }
 
 lcbio_pSSLCTX
-lcbio_ssl_new__fallback(const char *ca, int noverify, lcb_error_t *errp,
-    lcb_settings *settings)
+lcbio_ssl_new__fallback(const char *, int, lcb_error_t *errp,
+    lcb_settings *)
 {
-    (void)ca; (void)noverify; (void)settings;
     if (errp) { *errp = LCB_CLIENT_FEATURE_UNAVAILABLE; }
     return NULL;
 }
 
 
 #ifdef LCB_NO_SSL
-void lcbio_ssl_free(lcbio_pSSLCTX a) {
-    (void)a;
+void lcbio_ssl_free(lcbio_pSSLCTX) {
 }
-lcb_error_t lcbio_ssl_apply(lcbio_SOCKET *a, lcbio_pSSLCTX b) {
-    (void)a;(void)b;
+lcb_error_t lcbio_ssl_apply(lcbio_SOCKET*, lcbio_pSSLCTX) {
     return LCB_CLIENT_FEATURE_UNAVAILABLE;
 }
-int lcbio_ssl_check(lcbio_SOCKET *s) {
-    (void)s;
+int lcbio_ssl_check(lcbio_SOCKET*) {
     return 0;
 }
-lcb_error_t lcbio_ssl_get_error(lcbio_SOCKET *s) {
-    (void)s;
+lcb_error_t lcbio_ssl_get_error(lcbio_SOCKET *) {
     return LCB_SUCCESS;
 }
 void lcbio_ssl_global_init(void) {
 }
-lcb_error_t lcbio_sslify_if_needed(lcbio_SOCKET *s, lcb_settings *st) {
-    (void)s;(void)st;
+lcb_error_t lcbio_sslify_if_needed(lcbio_SOCKET *, lcb_settings *) {
     return LCB_SUCCESS;
 }
 #endif

data/ext/libcouchbase/src/lcbio/ioutils.h

@@ -92,9 +92,17 @@ lcbio_get_nameinfo(lcbio_SOCKET *sock, struct lcbio_NAMEINFO *nistrs);
 int
 lcbio_is_netclosed(lcbio_SOCKET *sock, int flags);
 
-/** Disable Nagle's algorithm on the socket */
+/**
+ * Enable an option on a socket
+ * @param sock The socket
+ * @param cntl The option (LCB_IO_CNTL_xxx)
+ * @return
+ */
 lcb_error_t
-lcbio_disable_nagle(lcbio_SOCKET *s);
+lcbio_enable_sockopt(lcbio_SOCKET *sock, int cntl);
+
+const char *
+lcbio_strsockopt(int cntl);
 
 void
 lcbio__load_socknames(lcbio_SOCKET *sock);
@@ -105,99 +113,30 @@ lcbio__load_socknames(lcbio_SOCKET *sock);
 #define lcbio_syserrno errno
 #endif
 
+#ifdef __cplusplus
+}
 
-/**
- * @addtogroup lcbio
- * @{
- *
- * @name Pending Requests
- * @{
- *
- * The lcbio_CONNREQ structure may contain various forms of pending requests
- * which are _cancellable_. This is useful to act as an abstraction over the
- * various helper functions which may be employed to initiate a new connection
- * or negotiate an existing one.
- *
- * The semantics of a _cancellable_ request are:
- *
- * <ul>
- * <li>They represent a pending operation</li>
- * <li>When cancelled, the pending operation is invalidated. This means that
- * any callbacks scheduled as a result of the operation will not be invoked.
- * </li>
- *
- * <li>If the pending operation has completed, the request is invalidated. This
- * means the pointer for the request is considered invalid once the operation
- * has completed
- * </li>
- * </ul>
- */
-
-/**
- * @brief Container object for various forms of cancellable requests.
- */
-typedef struct {
-    int type; /**< One of the LCBIO_CONNREQ_* constants */
-    #define LCBIO_CONNREQ_RAW 1
-    #define LCBIO_CONNREQ_POOLED 2
-    #define LCBIO_CONNREQ_GENERIC 3
-    union {
-        struct lcbio_CONNSTART *cs; /**< from lcbio_connect() */
-        struct lcbio_MGRREQ *preq; /**< from lcbio_mgr_get() */
-        void *p_generic; /**< Generic pointer. Destroyed via the dtor field */
-    } u;
-    void (*dtor)(void *);
-} lcbio_CONNREQ;
-
-/** @brief Clear an existing request, setting the pointer to NULL */
-#define LCBIO_CONNREQ_CLEAR(req) (req)->u.p_generic = NULL
-
-/**
- * @brief Initialize a connreq with an lcbio_pCONNSTART handle
- * @param req the request to initialize
- * @param cs the lcbio_pCONNSTART returned by lcbio_connect()
- */
-#define LCBIO_CONNREQ_MKRAW(req, cs) do { \
-    (req)->u.cs = cs; \
-    (req)->type = LCBIO_CONNREQ_RAW; \
-} while (0);
-
-/**
- * @brief Initialize a connreq with an lcbio_pMGRREQ
- * @param req The request to initialize
- * @param sreq the lcbio_pMGRREQ returned by lcbio_mgr_get()
- */
-#define LCBIO_CONNREQ_MKPOOLED(req, sreq) do { \
-    (req)->u.preq = sreq; \
-    (req)->type = LCBIO_CONNREQ_POOLED; \
-} while (0);
+namespace lcb {
+namespace io {
 
 /**
- * Initialize a connreq with a generic pointer.
- * @param req The request to initialize
- * @param p the pointer representing the request
- * @param dtorcb a callback invoked with `p` when the request has been cancelled
+ * This interface defines a pending connection request. It may be
+ * cancelled.
  */
-#define LCBIO_CONNREQ_MKGENERIC(req, p, dtorcb) do { \
-    (req)->u.p_generic = p; \
-    (req)->type = LCBIO_CONNREQ_GENERIC; \
-    (req)->dtor = (void (*)(void *))dtorcb; \
-} while (0);
-
-/**
- * @brief cancels a pending request, if not yet cancelled.
- *
- * Cancels a pending request. If the request has already been cancelled (by
- * calling this function), then this function does nothing
- * @param req The request to cancel
- */
-void
-lcbio_connreq_cancel(lcbio_CONNREQ *req);
-
-/**@}*/
-/**@}*/
+class ConnectionRequest {
+public:
+    virtual void cancel() = 0;
+    virtual ~ConnectionRequest() {}
+    static void cancel(ConnectionRequest **pp) {
+        if (*pp) {
+            (*pp)->cancel();
+            *pp = NULL;
+        }
+    }
+};
 
-#ifdef __cplusplus
 }
+}
+
 #endif
 #endif