libcouchbase 0.0.1

data/ext/libcouchbase/contrib/win32-defs/win_stdint.h

@@ -0,0 +1,258 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+//  Copyright (c) 2006-2009 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _MSC_VER // [
+#define _MSC_STDINT_H_
+#include <stdint.h>
+#endif // _MSC_VER ]
+
+#if _MSC_VER >= 1600
+#include <stdint.h>
+#else
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#if (_MSC_VER < 1300) && defined(__cplusplus)
+extern "C++" {
+#endif
+#     include <wchar.h>
+#if (_MSC_VER < 1300) && defined(__cplusplus)
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+typedef __int8            int8_t;
+typedef __int16           int16_t;
+#ifndef int32_t
+typedef __int32           int32_t;
+#endif
+#ifndef int64_t
+typedef __int64           int64_t;
+#endif
+#ifndef uint8_t
+typedef unsigned __int8   uint8_t;
+#endif
+#ifndef u_char
+typedef unsigned __int8   u_char;
+#endif
+typedef unsigned __int16  uint16_t;
+#ifndef uint32_t
+typedef unsigned __int32  uint32_t;
+#endif
+typedef unsigned __int64  uint64_t;
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint32_t  u_int32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+typedef __int64           intptr_t;
+typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+typedef _W64 int               intptr_t;
+typedef _W64 unsigned int      uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#if _MSC_VER < 1600
+static __inline int64_t llabs(int64_t i)
+{
+    return i >= 0 ? i : -i;
+}
+#endif
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#endif // _MSC_VER < 1600
+
+#endif // _MSC_STDINT_H_ ]

data/ext/libcouchbase/example/CMakeLists.txt

@@ -0,0 +1,37 @@
+# This builds the examples; all these targets are optional
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/examples")
+
+MACRO(ADD_EXAMPLE name dir linkspec incspec)
+    SET(dir "${CMAKE_CURRENT_SOURCE_DIR}/${dir}")
+    FILE(GLOB _cur_src ${dir}/*.cc ${dir}/*.c ${dir}/*.cpp)
+    ADD_EXECUTABLE(${name} ${_cur_src})
+    TARGET_LINK_LIBRARIES(${name} couchbase ${linkspec})
+
+    GET_TARGET_PROPERTY(_tmp_inc ${name} INCLUDE_DIRECTORIES)
+    LIST(APPEND ${_tmp_inc} ${dir} ${incspec})
+    SET_TARGET_PROPERTIES(${name} PROPERTIES INCLUDE_DIRECTORIES "${_tmp_inc}")
+ENDMACRO()
+
+# ADD_EXAMPLE(db db "" "")
+ADD_EXECUTABLE(db db/db.c)
+ADD_EXECUTABLE(vb db/vb.c)
+TARGET_LINK_LIBRARIES(db couchbase)
+TARGET_LINK_LIBRARIES(vb couchbase)
+
+ADD_EXAMPLE(mcc mcc "" "")
+ADD_EXAMPLE(minimal minimal "" "")
+ADD_EXAMPLE(observe observe "" "")
+ADD_EXAMPLE(views-example views "" "")
+ADD_EXAMPLE(tick tick "" "")
+
+ADD_EXECUTABLE(subdoc-simple subdoc/subdoc-simple.cc)
+ADD_EXECUTABLE(subdoc-multi subdoc/subdoc-multi.cc)
+TARGET_LINK_LIBRARIES(subdoc-simple couchbase)
+TARGET_LINK_LIBRARIES(subdoc-multi couchbase)
+
+IF(NOT WIN32)
+    ADD_EXAMPLE(instancepool instancepool pthread "")
+ENDIF()
+IF(HAVE_LIBEVENT2)
+    ADD_EXAMPLE(libevent-direct libeventdirect ${LIBEVENT_LIBRARIES} ${LIBEVENT_INCLUDE_DIR})
+ENDIF()

data/ext/libcouchbase/example/README.markdown

@@ -0,0 +1,47 @@
+Examples
+========
+
+An example says more than a 1000 words (and its way easier to write an
+example than trying to explain something). In this directory you'll
+find a varity of examples that will show you different use patterns of
+libcoucbase.
+
+libeventdirect
+--------------
+
+This example programs shows you how you may integrate libcouchbase
+into your own event loop (in this example libevent).
+
+syncmode
+--------
+
+This example shows you how you may use the synchronous interface of
+libcouchbase.
+
+yajl
+----
+
+This is an example that shows you how to work with views and json
+
+pillowfight
+-----------
+
+This is an example that implements a small test program to show
+you some of the functionalities in libcouchbase.
+
+minimal
+-------
+
+This is an minimal single-file example which works both unix-like and windows OS.
+It accepts three arguments: "host:port", "bucket" and "password".
+
+Build:
+
+     gcc -lcouchbase -o minimal minimal.c
+     cl /DWIN32 /Iinclude lib\libcouchbase.lib minimal.c
+
+Execute:
+
+     valgrind -v --tool=memcheck  --leak-check=full --show-reachable=yes ./minimal
+     ./minimal <host:port> <bucket> <passwd>
+     mininal.exe <host:port> <bucket> <passwd>

data/ext/libcouchbase/example/db/db.c

@@ -0,0 +1,167 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 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.
+ */
+
+/* Dumb Benchmark. This application is using libcouchbase to store
+ * single key and then get this key back infinitely.
+ *
+ * BUILD:
+ *
+ *      cc -o db db.c -lcouchbase
+ *      cl /DWIN32 /Iinclude db.c lib\libcouchbase.lib
+ *
+ * RUN:
+ *
+ *      valgrind -v --tool=memcheck  --leak-check=full --show-reachable=yes ./db
+ *      ./db key size <host:port> <bucket> <passwd>
+ *      db.exe key size <host:port> <bucket> <passwd>
+ */
+#include <stdio.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/api3.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#ifdef _WIN32
+#define PRIu64 "I64u"
+#else
+#include <signal.h>
+#include <inttypes.h>
+#endif
+
+#ifndef _WIN32
+static void handle_sigint(int sig)
+{
+    (void)sig;
+    printf("Exiting on SIGINT\n");
+    exit(0);
+}
+
+#define INSTALL_SIGINT_HANDLER() signal(SIGINT, handle_sigint)
+#else
+#define INSTALL_SIGINT_HANDLER()
+#endif
+
+static void store_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    if (rb->rc != LCB_SUCCESS) {
+        fprintf(stderr, "Couldn't perform initial storage: %s\n", lcb_strerror(NULL, rb->rc));
+        exit(EXIT_FAILURE);
+    }
+    (void)cbtype; /* unused argument */
+}
+
+static void get_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
+{
+    if (rb->rc == LCB_SUCCESS) {
+        lcb_CMDGET gcmd = { 0 };
+        lcb_error_t rc;
+        LCB_CMD_SET_KEY(&gcmd, rb->key, rb->nkey);
+        rc = lcb_get3(instance, NULL, &gcmd);
+        if (rc != LCB_SUCCESS) {
+            fprintf(stderr, "Failed to schedule get operation: %s\n", lcb_strerror(NULL, rc));
+            exit(EXIT_FAILURE);
+        }
+    } else {
+        fprintf(stderr, "Failed to retrieve key: %s\n", lcb_strerror(NULL, rb->rc));
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    lcb_error_t err;
+    lcb_t instance;
+    struct lcb_create_st create_options;
+    const char *key = "foo";
+    size_t nkey = strlen(key);
+    void *bytes;
+    long nbytes = 6; /* the size of the value */
+
+    memset(&create_options, 0, sizeof(create_options));
+    create_options.version = 3;
+
+    if (argc > 1) {
+        key = argv[1];
+        nkey = strlen(key);
+    }
+    if (argc > 2) {
+        nbytes = atol(argv[2]);
+    }
+    if (argc > 3) {
+        create_options.v.v3.connstr = argv[3];
+    }
+    if (argc > 4) {
+        create_options.v.v3.passwd = argv[4];
+    }
+
+    INSTALL_SIGINT_HANDLER();
+
+    err = lcb_create(&instance, &create_options);
+    if (err != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to create libcouchbase instance: %s\n", lcb_strerror(NULL, err));
+        exit(EXIT_FAILURE);
+    }
+
+    /* Initiate the connect sequence in libcouchbase */
+    if ((err = lcb_connect(instance)) != LCB_SUCCESS) {
+        fprintf(stderr, "Failed to initiate connect: %s\n", lcb_strerror(NULL, err));
+        lcb_destroy(instance);
+        exit(EXIT_FAILURE);
+    }
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    if ((err = lcb_get_bootstrap_status(instance)) != LCB_SUCCESS) {
+        fprintf(stderr, "Couldn't establish connection to cluster: %s\n", lcb_strerror(NULL, err));
+        lcb_destroy(instance);
+        exit(EXIT_FAILURE);
+    }
+
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, get_callback);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, store_callback);
+
+    fprintf(stderr, "key: \"%s\"\n", key);
+    fprintf(stderr, "value size: %ld\n", nbytes);
+    fprintf(stderr, "connection string: %s\n", create_options.v.v3.connstr ? create_options.v.v3.connstr : "");
+    fprintf(stderr, "password: %s\n", create_options.v.v0.passwd ? create_options.v.v3.passwd : "");
+
+    bytes = malloc(nbytes);
+
+    {
+        lcb_CMDSTORE cmd = { 0 };
+        cmd.operation = LCB_SET;
+        LCB_CMD_SET_KEY(&cmd, key, nkey);
+        LCB_CMD_SET_VALUE(&cmd, bytes, nbytes);
+        err = lcb_store3(instance, NULL, &cmd);
+        if (err != LCB_SUCCESS) {
+            fprintf(stderr, "Failed to store: %s\n", lcb_strerror(NULL, err));
+            exit(EXIT_FAILURE);
+        }
+    }
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    fprintf(stderr, "Benchmarking... CTRL-C to stop\n");
+    {
+        lcb_CMDGET cmd = { 0 };
+        LCB_CMD_SET_KEY(&cmd, key, nkey);
+        err = lcb_get3(instance, NULL, &cmd);
+        if (err != LCB_SUCCESS) {
+            fprintf(stderr, "Failed to get: %s\n", lcb_strerror(NULL, err));
+            exit(EXIT_FAILURE);
+        }
+    }
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    lcb_destroy(instance);
+
+    exit(EXIT_SUCCESS);
+}