libcouchbase 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f194c4e3e8555e79f283ca6871be76d79b4bb480
-  data.tar.gz: b1c06f4435765ab5d796f070e02a8f5dc9ea8942
+  metadata.gz: ff0956b1087675795458772e87ba168c045ef2f6
+  data.tar.gz: 715ef9e7bd70e6fe4996fdaf9eaee7ec3a5c9ccd
 SHA512:
-  metadata.gz: 0e5e60d1ee7e2cd4ac7497a719a7c75896fe4204d54c40ed620073bc2b50003dc94f8479436108d875642aa4bbe5cd374629c745e8e624fbf02cb4b8493f3034
-  data.tar.gz: e92e37450112794f8d95be56bcdc2e75d18a7978bb87b042d06a42e215f2af82c61e9bb075625c2dcf5e5210abb1af2050dbcbe75a01f970a383dfdab9eb35aa
+  metadata.gz: e8d2e5dc66ff778f2353837027e746a38fa56fc2f81163fea892c43d15151625f4e6bfb70d0447b4c9a627af050c0a10f830cb92bde36f4c9778e66cac7a2474
+  data.tar.gz: 028f7bfb147658012fb3556f4fdf86601f7d8b7c64a5f0b4435e5b7f6c74180225e1201166d1bcea462c2da2f4cfb8a02046a55d01bb7813608859d73c168a08

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2013 Cotag Media
+Copyright (c) 2016 ACAProjects
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -20,5 +20,5 @@ THE SOFTWARE.
 
 ===
 
-This license applies to all parts of uvrb (Ruby FFI bindings for libuv only)
-Libuv itself [is using Node license](https://github.com/joyent/libuv/blob/master/LICENSE)
+This license applies to all parts of the libcouchbase gem (Ruby FFI bindings for libcouchbase only)
+Libcouchbase itself [is using the Couchbase license](https://github.com/couchbase/libcouchbase/blob/master/LICENSE)

data/README.md

@@ -105,16 +105,11 @@ The library supports three different formats for representing values:
 * `:marshal` Use this format if you'd like to transparently serialize your
   ruby object with standard `Marshal.dump` and `Marshal.load` methods
 
-The library supports both synchronous and asynchronous mode. In
-asynchronous mode all operations will return control to caller
-without blocking current thread. You can collect references to these
-async operations and then wait for the results on the current thread
-or the results can be processed in a callback.
-
 ```ruby
 bucket.put(:some_object, my_object, format: :marshal)
 ```
 
+
 The library supports both synchronous and asynchronous operations.
 In asynchronous mode all operations will return control to caller
 without blocking current thread. By default all operations are
@@ -133,10 +128,10 @@ bucket.wait_results(results)          #=> ['key1_val', 'key2_val']
 # Is equivalent to:
 bucket.get(:key1, :key2)              #=> ['key1_val', 'key2_val']
 
-# Process result without waiting / blocking the thread at all
+# Process result without waiting or blocking the thread at all
 # This will execute on the couchbase reactor loop so it is
-# recommended not to block, spin up a new thread or schedule the
-# work to occur next_tick etc
+# recommended not to block in the callback - spin up a new thread
+# or schedule the work to occur next_tick etc
 promise = bucket.get(:key1, async: true)
 promise.then  { |result| puts result }
 promise.catch { |error|  puts error  }

data/ext/libcouchbase/include/libcouchbase/auth.h

@@ -0,0 +1,101 @@
+#ifndef LCB_AUTH_H
+#define LCB_AUTH_H
+
+#ifdef __cplusplus
+namespace lcb { class Authenticator; }
+typedef lcb::Authenticator lcb_AUTHENTICATOR;
+extern "C" {
+#else /* C only! */
+typedef struct lcb_AUTHENTICATOR_Cdummy lcb_AUTHENTICATOR;
+#endif
+
+/**
+ * @class lcb_AUTHENTICATOR
+ *
+ * The lcb_AUTHENTICATOR object allows greater flexibility with regard to
+ * adding more than a single bucket/password credential pair. It also restores
+ * the ability to use "true" usernames (though these are not used at present
+ * yet).
+ */
+
+/**
+ * @volatile
+ * Creates a new authenticator object. You may destroy it using lcbauth_unref().
+ * The returned object initially has a refcount of 1.
+ *
+ * @return A new authenticator object.
+ */
+LIBCOUCHBASE_API
+lcb_AUTHENTICATOR *
+lcbauth_new(void);
+
+/**
+ * Flags to use when adding a new set of credentials to lcbauth_add_pass
+ */
+typedef enum {
+    /** User/Password is administrative; for cluster */
+    LCBAUTH_F_CLUSTER = 1<<1,
+
+    /** User is bucket name. Password is bucket password */
+    LCBAUTH_F_BUCKET = 1<<2
+} lcbauth_ADDPASSFLAGS;
+
+/**
+ * @volatile
+ *
+ * Add a set of credentials
+ * @param auth
+ * @param user the username (or bucketname, if LCBAUTH_F_BUCKET is passed)
+ * @param pass the password. If the password is NULL, the credential is removed
+ * @param flags one of @ref LCBAUTH_F_CLUSTER or @ref LCBAUTH_F_BUCKET.
+ */
+LIBCOUCHBASE_API
+lcb_error_t
+lcbauth_add_pass(lcb_AUTHENTICATOR *auth, const char *user, const char *pass, int flags);
+
+/**
+ * @volatile
+ *
+ * Gets the global username and password. This is either the lone bucket
+ * password, or an explicit cluster password.
+ * @param auth
+ * @param[out] u Global username
+ * @param[out] p Global password
+ */
+void
+lcbauth_get_upass(const lcb_AUTHENTICATOR *auth, const char **u, const char **p);
+
+
+/**
+ * @private
+ *
+ * Get a user/bucket password
+ * @param auth the authenticator
+ * @param name the name of the bucket
+ * @return the password for the bucket, or NULL if the bucket has no password
+ * (or is unknown to the authenticator)
+ */
+const char *
+lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *name);
+
+/**
+ * @uncomitted
+ * Increments the refcount on the authenticator object
+ * @param auth
+ */
+LIBCOUCHBASE_API
+void
+lcbauth_ref(lcb_AUTHENTICATOR *auth);
+
+/**
+ * Decrements the refcount on the authenticator object
+ * @param auth
+ */
+LIBCOUCHBASE_API
+void
+lcbauth_unref(lcb_AUTHENTICATOR *auth);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* LCB_AUTH_H */

data/ext/libcouchbase/include/libcouchbase/couchbase.h

@@ -54,6 +54,7 @@ typedef struct lcb_http_request_st *lcb_http_request_t;
 #include <libcouchbase/http.h>
 #include <libcouchbase/configuration.h>
 #include <libcouchbase/kvbuf.h>
+#include <libcouchbase/auth.h>
 #include <libcouchbase/_cxxwrap.h>
 
 #ifdef __cplusplus
@@ -387,6 +388,18 @@ lcb_set_bootstrap_callback(lcb_t instance, lcb_bootstrap_callback callback);
 LIBCOUCHBASE_API
 lcb_error_t
 lcb_get_bootstrap_status(lcb_t instance);
+
+/**
+ * Sets the authenticator object for the instance. This may be done anytime, but
+ * should probably be done before calling `lcb_connect()` for best effect.
+ *
+ * @param instance the handle
+ * @param auth the authenticator object used. The library will increase the
+ * refcount on the authenticator object.
+ */
+LIBCOUCHBASE_API
+void
+lcb_set_auth(lcb_t instance, lcb_AUTHENTICATOR *auth);
 /**@}*/
 
 

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

@@ -0,0 +1,34 @@
+#ifndef LCB_AUTH_PRIV_H
+#define LCB_AUTH_PRIV_H
+#include <libcouchbase/auth.h>
+
+#ifdef __cplusplus
+#include <string>
+#include <map>
+
+namespace lcb {
+class Authenticator {
+public:
+    typedef std::map<std::string,std::string> Map;
+    const std::string& username() const { return m_username; }
+    const std::string& password() const { return m_password; }
+    const Map& buckets() const { return m_buckets; }
+    Authenticator() : m_refcount(1) {}
+
+    size_t refcount() const { return m_refcount; }
+    void incref() { ++m_refcount; }
+    void decref() { if (!--m_refcount) { delete this; } }
+    lcb_error_t add(const char *user, const char *pass, int flags);
+    lcb_error_t init(const std::string& username_, const std::string& bucket,
+        const std::string& password, lcb_type_t conntype);
+
+private:
+    // todo: refactor these out
+    Map m_buckets;
+    std::string m_username;
+    std::string m_password;
+    size_t m_refcount;
+};
+}
+#endif
+#endif /* LCB_AUTH_H */

data/ext/libcouchbase/src/auth.cc

@@ -1,5 +1,5 @@
 #include <libcouchbase/couchbase.h>
-#include "auth.h"
+#include "auth-priv.h"
 
 using namespace lcb;
 
@@ -9,53 +9,78 @@ lcbauth_new()
     return new Authenticator();
 }
 
-void
-lcbauth_free(lcb_AUTHENTICATOR *auth)
-{
-    delete auth;
-}
-
 const char *
 lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *u)
 {
-    Authenticator::Map::const_iterator ii = auth->m_buckets.find(u);
-    if (ii == auth->m_buckets.end()) {
+    Authenticator::Map::const_iterator ii = auth->buckets().find(u);
+    if (ii == auth->buckets().end()) {
         return NULL;
     }
     return ii->second.c_str();
 }
 
+lcb_error_t
+lcbauth_add_pass(lcb_AUTHENTICATOR *auth, const char *u, const char *p, int flags)
+{
+    return auth->add(u, p, flags);
+}
+
+lcb_error_t
+Authenticator::add(const char *u, const char *p, int flags)
+{
+    if (!flags) {
+        return LCB_EINVAL;
+    }
+
+    if (flags & LCBAUTH_F_CLUSTER) {
+        if (!p) {
+            m_username.clear();
+            m_password.clear();
+        } else {
+            m_username = u;
+            m_password = p;
+        }
+    }
+    if (flags & LCBAUTH_F_BUCKET) {
+        if (!p) {
+            m_buckets.erase(u);
+        } else {
+            m_buckets[u] = p;
+        }
+    }
+    return LCB_SUCCESS;
+}
+
 void
-lcbauth_set(lcb_AUTHENTICATOR *auth, const char *u, const char *p,
-    int is_global)
+lcbauth_get_upass(const lcb_AUTHENTICATOR *auth, const char **u, const char **p)
 {
-    if (is_global) {
-        auth->m_username = u;
-        auth->m_password = p;
+    if (!auth->username().empty()) {
+        *u = auth->username().c_str();
+        *p = auth->password().empty() ? NULL : auth->password().c_str();
+
+    } else if (!auth->buckets().empty()) {
+        Authenticator::Map::const_iterator it = auth->buckets().begin();
+        *u = it->first.c_str();
+        if (!it->second.empty()) {
+            *p = it->second.c_str();
+        } else {
+            *p = NULL;
+        }
     } else {
-        auth->m_buckets[u] = p;
+        *u = *p = NULL;
     }
 }
 
 void
-lcb_authenticator_clear(lcb_AUTHENTICATOR *auth)
+lcbauth_ref(lcb_AUTHENTICATOR *auth)
 {
-    auth->m_buckets.clear();
+    auth->incref();
 }
 
 void
-lcbauth_get_upass(const lcb_AUTHENTICATOR *auth, const char **u, const char **p)
+lcbauth_unref(lcb_AUTHENTICATOR *auth)
 {
-    if (!auth->m_username.empty()) {
-        *u = auth->m_username.c_str();
-    } else {
-        *u = NULL;
-    }
-    if (!auth->m_password.empty()) {
-        *p = auth->m_password.c_str();
-    } else {
-        *p = NULL;
-    }
+    auth->decref();
 }
 
 lcb_error_t

data/ext/libcouchbase/src/cntl.cc

@@ -497,7 +497,7 @@ HANDLER(bucket_auth_handler) {
     if (mode == LCB_CNTL_SET) {
         /* Parse the bucket string... */
         cred = (const lcb_BUCKETCRED *)arg;
-        lcbauth_set(instance->settings->auth, (*cred)[0], (*cred)[1], 0);
+        lcbauth_add_pass(instance->settings->auth, (*cred)[0], (*cred)[1], LCBAUTH_F_BUCKET);
         (void)cmd; (void)arg;
     } else if (mode == CNTL__MODE_SETSTRING) {
         const char *ss = reinterpret_cast<const char *>(arg);
@@ -509,9 +509,9 @@ HANDLER(bucket_auth_handler) {
         if (!root.isArray() || root.size() != 2) {
             return LCB_ECTL_BADARG;
         }
-        lcbauth_set(instance->settings->auth,
+        lcbauth_add_pass(instance->settings->auth,
             root[0].asString().c_str(),
-            root[1].asString().c_str(), 0);
+            root[1].asString().c_str(), LCBAUTH_F_BUCKET);
     } else {
         return LCB_ECTL_UNSUPPMODE;
     }

data/ext/libcouchbase/src/http/http.cc

@@ -433,7 +433,12 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         if (cmd->cmdflags & LCB_CMDHTTP_F_NOUPASS) {
             username = password = NULL;
         } else if (username == NULL && password == NULL) {
-            lcbauth_get_upass(LCBT_SETTING(instance, auth), &username, &password);
+            if (reqtype == LCB_HTTP_TYPE_MANAGEMENT) {
+                lcbauth_get_upass(LCBT_SETTING(instance, auth), &username, &password);
+            } else {
+                username = LCBT_SETTING(instance, bucket);
+                password = lcbauth_get_bpass(LCBT_SETTING(instance, auth), username);
+            }
         }
 
         base = get_api_node(rc);

data/ext/libcouchbase/src/instance.cc

@@ -15,6 +15,7 @@
  *   limitations under the License.
  */
 #include "internal.h"
+#include "auth-priv.h"
 #include "connspec.h"
 #include "logging.h"
 #include "hostlist.h"
@@ -51,6 +52,16 @@ const void *lcb_get_cookie(lcb_t instance)
     return instance->cookie;
 }
 
+LIBCOUCHBASE_API
+void
+lcb_set_auth(lcb_t instance, lcb_AUTHENTICATOR *auth)
+{
+    /* First increase refcount in case they are the same object(!) */
+    lcbauth_ref(auth);
+    lcbauth_unref(instance->settings->auth);
+    instance->settings->auth = auth;
+}
+
 void
 lcb_st::add_bs_host(const char *host, int port, unsigned bstype)
 {

data/ext/libcouchbase/src/mcserver/negotiate.c

@@ -76,8 +76,8 @@ sasl_get_username(void *context, int id, const char **result, unsigned int *len)
     if (!context || !result || (id != CBSASL_CB_USER && id != CBSASL_CB_AUTHNAME)) {
         return SASL_BADPARAM;
     }
-
-    lcbauth_get_upass(ctx->settings->auth, &u, &p);
+    u = ctx->settings->bucket;
+    p = lcbauth_get_bpass(ctx->settings->auth, ctx->settings->bucket);
     *result = u;
     if (len) {
         *len = (unsigned int)strlen(*result);
@@ -124,7 +124,8 @@ setup_sasl_params(struct mc_SESSINFO *ctx)
     }
 
     memset(&ctx->u_auth, 0, sizeof(ctx->u_auth));
-    lcbauth_get_upass(ctx->settings->auth, &user, &pass);
+    user = ctx->settings->bucket;
+    pass = lcbauth_get_bpass(ctx->settings->auth, user);
 
     if (pass) {
         unsigned long pwlen;

data/ext/libcouchbase/src/n1ql/n1ql.cc

@@ -2,6 +2,7 @@
 #include <libcouchbase/n1ql.h>
 #include <jsparse/parser.h>
 #include "internal.h"
+#include "auth-priv.h"
 #include "http/http.h"
 #include "logging.h"
 #include "contrib/lcb-jsoncpp/lcb-jsoncpp.h"

data/ext/libcouchbase/src/settings.c

@@ -18,7 +18,6 @@
 #include "settings.h"
 #include <lcbio/ssl.h>
 #include <rdb/rope.h>
-#include "auth.h"
 
 LCB_INTERNAL_API
 void lcb_default_settings(lcb_settings *settings)
@@ -83,7 +82,7 @@ lcb_settings_unref(lcb_settings *settings)
     free(settings->certpath);
     free(settings->client_string);
 
-    lcbauth_free(settings->auth);
+    lcbauth_unref(settings->auth);
 
     if (settings->ssl_ctx) {
         lcbio_ssl_free(settings->ssl_ctx);

data/ext/libcouchbase/src/settings.h

@@ -17,7 +17,6 @@
 
 #ifndef LCB_SETTINGS_H
 #define LCB_SETTINGS_H
-#include "auth.h"
 
 /**
  * Handy macros for converting between different time resolutions

data/ext/libcouchbase/tests/basic/t_creds.cc

@@ -1,6 +1,6 @@
 #include "config.h"
 #include "internal.h"
-#include "auth.h"
+#include "auth-priv.h"
 #include <gtest/gtest.h>
 #define LIBCOUCHBASE_INTERNAL 1
 #include <libcouchbase/couchbase.h>
@@ -15,8 +15,8 @@ TEST_F(CredsTest, testCreds)
     lcb_BUCKETCRED cred;
     ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance, NULL));
     lcb::Authenticator& auth = *instance->settings->auth;
-    ASSERT_FALSE(auth.m_username.empty());
-    ASSERT_EQ("default", auth.m_username);
+    ASSERT_FALSE(auth.username().empty());
+    ASSERT_EQ("default", auth.username());
 
     ASSERT_EQ(1, auth.buckets().size());
     ASSERT_TRUE(auth.buckets().find("default")->second.empty());
@@ -26,7 +26,29 @@ TEST_F(CredsTest, testCreds)
     ASSERT_EQ(LCB_SUCCESS, lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_BUCKET_CRED, creds));
     ASSERT_EQ(2, auth.buckets().size());
     ASSERT_EQ("pass2", auth.buckets().find("user2")->second);
-    ASSERT_EQ("default", auth.m_username);
-    ASSERT_EQ("", auth.m_password);
+    ASSERT_EQ("default", auth.username());
+    ASSERT_EQ("", auth.password());
     lcb_destroy(instance);
 }
+
+TEST_F(CredsTest, testSharedAuth)
+{
+    lcb_t instance1, instance2;
+    ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance1, NULL));
+    ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance2, NULL));
+
+    lcb_AUTHENTICATOR *auth = lcbauth_new();
+    ASSERT_EQ(1, auth->refcount());
+
+    lcb_set_auth(instance1, auth);
+    ASSERT_EQ(2, auth->refcount());
+
+    lcb_set_auth(instance2, auth);
+    ASSERT_EQ(3, auth->refcount());
+
+    ASSERT_EQ(instance1->settings->auth, instance2->settings->auth);
+    lcb_destroy(instance1);
+    lcb_destroy(instance2);
+    ASSERT_EQ(1, auth->refcount());
+    lcbauth_unref(auth);
+}

data/lib/libcouchbase/bucket.rb

@@ -81,10 +81,12 @@ module Libcouchbase
         # @example Get and lock multiple keys using custom timeout
         #   c.get("foo", "bar", lock: 3)
         def get(*keys, extended: false, async: false, quiet: @quiet, assemble_hash: false, **opts)
+            keys = keys.flatten
+
             if keys.length == 1
                 promise = @connection.get(keys[0], **opts)
 
-                if not extended
+                unless extended
                     promise = promise.then(proc { |resp|
                         resp.value
                     })
@@ -604,8 +606,8 @@ module Libcouchbase
             attrs[:language] ||= :javascript
 
             id ||= attrs.delete(:_id)
-            id = id.sub(/^_design\//, '')
-            
+            id = id.to_s.sub(/^_design\//, '')
+
             result @connection.http("/_design/#{id}",
                 method: :put,
                 body: attrs,

data/lib/libcouchbase/design_docs.rb

@@ -46,6 +46,7 @@ module Libcouchbase
         protected
 
 
+        # This is a proxy to the Bucket#result method
         def result(promise)
             @result.call(promise)
         end
@@ -75,10 +76,15 @@ module Libcouchbase
         end
         alias_method :[], :view
 
+        def view_config
+            @row[:json][:views]
+        end
+
 
         protected
 
 
+        # This is a proxy to the Bucket#result method
         def result(promise)
             @result.call(promise)
         end

data/lib/libcouchbase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true, encoding: ASCII-8BIT
 
 module Libcouchbase
-    VERSION = '0.0.1'
+    VERSION = '0.0.2'
 end

data/spec/design_docs_spec.rb

@@ -20,4 +20,12 @@ describe Libcouchbase::DesignDocs do
         views = @ddoc[:user].views
         expect(views).to eq([:is_sys_admin])
     end
+
+    it "should provide access to view configuration" do
+        config = @ddoc.design("user").view_config
+        expect(config.keys).to eq([:is_sys_admin])
+
+        config = @ddoc[:user].view_config
+        expect(config.keys).to eq([:is_sys_admin])
+    end
 end

data/spec/view_spec.rb

@@ -54,8 +54,8 @@ describe Libcouchbase::QueryView do
         it "should create a design document" do
             doc = {
                 _id: "_design/blog",
-                    language: "javascript",
-                    views: {
+                language: "javascript",
+                views: {
                     recent_posts: {
                         map: "function(doc){if(doc.date && doc.title){emit(doc.date, doc.title);}}"
                     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libcouchbase
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Stephen von Takach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-31 00:00:00.000000000 Z
+date: 2016-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -317,6 +317,7 @@ files:
 - ext/libcouchbase/include/libcouchbase/api-legacy.h
 - ext/libcouchbase/include/libcouchbase/api3.h
 - ext/libcouchbase/include/libcouchbase/assert.h
+- ext/libcouchbase/include/libcouchbase/auth.h
 - ext/libcouchbase/include/libcouchbase/cbft.h
 - ext/libcouchbase/include/libcouchbase/cntl-private.h
 - ext/libcouchbase/include/libcouchbase/cntl.h
@@ -384,8 +385,8 @@ files:
 - ext/libcouchbase/plugins/io/select/select_io_opts.h
 - ext/libcouchbase/src/README.md
 - ext/libcouchbase/src/aspend.h
+- ext/libcouchbase/src/auth-priv.h
 - ext/libcouchbase/src/auth.cc
-- ext/libcouchbase/src/auth.h
 - ext/libcouchbase/src/bootstrap.c
 - ext/libcouchbase/src/bootstrap.h
 - ext/libcouchbase/src/bucketconfig/bc_cccp.c

data/ext/libcouchbase/src/auth.h

@@ -1,54 +0,0 @@
-#ifndef LCB_AUTH_H
-#define LCB_AUTH_H
-
-#ifdef __cplusplus
-#include <map>
-#include <string>
-namespace lcb { class Authenticator; }
-typedef lcb::Authenticator lcb_AUTHENTICATOR;
-extern "C" {
-#else /* C only! */
-typedef struct lcb_AUTHENTICATOR_Cdummy lcb_AUTHENTICATOR;
-#endif
-
-lcb_AUTHENTICATOR *
-lcbauth_new(void);
-
-void
-lcbauth_free(lcb_AUTHENTICATOR *);
-
-const char *
-lcbauth_get_bpass(const lcb_AUTHENTICATOR *auth, const char *name);
-
-void
-lcbauth_set(lcb_AUTHENTICATOR *auth,
-    const char *user, const char *pass, int is_global);
-
-void
-lcb_authenticator_clear(lcb_AUTHENTICATOR *auth);
-
-void
-lcbauth_get_upass(const lcb_AUTHENTICATOR *auth,
-    const char **u, const char **p);
-
-#ifdef __cplusplus
-}
-namespace lcb {
-class Authenticator {
-public:
-    typedef std::map<std::string,std::string> Map;
-    const std::string& username() const { return m_username; }
-    const std::string& password() const { return m_password; }
-    const Map& buckets() const { return m_buckets; }
-
-    // todo: refactor these out
-    Map m_buckets;
-    std::string m_username;
-    std::string m_password;
-
-    lcb_error_t init(const std::string& username_, const std::string& bucket,
-        const std::string& password, lcb_type_t conntype);
-};
-}
-#endif
-#endif /* LCB_AUTH_H */