couchbase 1.0.0 → 1.1.0

data/.gitignore

@@ -7,6 +7,8 @@ core*
 doc/
 ext/couchbase/Makefile
 ext/couchbase/mkmf.log
+lib/couchbase_ext.rb
 pkg/*
+ports
 test/CouchbaseMock.jar
 tmp

data/.travis.yml

@@ -0,0 +1,11 @@
+before_install:
+  - wget -O- http://packages.couchbase.com/ubuntu/couchbase.key | sudo apt-key add -
+  - echo deb http://packages.couchbase.com/ubuntu lucid lucid/main | sudo tee /etc/apt/sources.list.d/couchbase.list
+  - sudo apt-get update
+  - sudo apt-get -y install libevent-dev libvbucket-dev libcouchbase-dev
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree

data/HISTORY.markdown

@@ -1,3 +1,20 @@
+## 1.1.0 / 2012-03-07
+
+* Timeout support (CCBC-20)
+* Implement disconnect/reconnect interface
+* Improve error handling code
+* Use URI parser from stdlib
+* Improve the documentation and the tests
+* Remove direct dependency on libevent
+* Remove sasl dependency
+* Fix storing empty line and nil
+* Allow running tests on real cluster
+* Cross-build for windows
+* Keep connections in thread local storage
+* Add block execution time to timeout
+* Implement VERSION command
+* Configure Travis-CI
+
 ## 1.0.0 / 2011-12-23
 
 * Implement all operations using libcouchbase as backend

data/README.markdown

@@ -1,59 +1,67 @@
-# Couchbase Ruby Client
+# Couchbase Ruby Client [![Build Status](https://secure.travis-ci.org/avsej/couchbase-ruby-client.png?branch=master)](http://travis-ci.org/avsej/couchbase-ruby-client)
 
 This is the official client library for use with Couchbase Server.
 
-## INSTALL
+## SUPPORT
+
+If you found an issue, please file it in our [JIRA][1]. Also you are
+always welcome on `#libcouchbase` channel at [freenode.net IRC servers][2].
 
-This gem depends on a couple of external libraries to work with JSON and
-Couchbase Server. For JSON it uses [yajl-ruby][1] which is built atop
-[yajl][2]. For Couchbase iteraction it uses [libcouchbase][3]. The first
-dependency shouldn't cause any issues because it will bundle yajl in the c
-extensions. To install yajl-ruby use following command:
+Documentation: [http://rdoc.info/gems/couchbase](http://rdoc.info/gems/couchbase)
 
-    $ gem install yajl-ruby
+## INSTALL
 
-In most cases installing libcouchbase is just as simple.
+This gem depends [libcouchbase][3]. In most cases installing
+libcouchbase doesn't take much effort.
 
 ### MacOS (Homebrew)
 
     $ brew install libcouchbase
 
-Or if our pull request isn't yet merged:
+Or if [our pull requests][4] for isn't yet merged:
 
-    $ brew install http://packages.couchbase.com/clients/c/homebrew/libvbucket.rb
-    $ brew install http://packages.couchbase.com/clients/c/homebrew/libcouchbase.rb
+    $ brew install https://github.com/avsej/homebrew/raw/libvbucket/Library/Formula/libvbucket.rb
+    $ brew install https://github.com/avsej/homebrew/raw/libcouchbase/Library/Formula/libcouchbase.rb
 
 ### Debian (Ubuntu)
 
-Download packages depending on your architecture:
+Add the appropriate line to /etc/apt/sources.list.d/couchbase.list for
+your OS release:
 
-    $ wget http://packages.couchbase.com/clients/c/libvbucket{1,1-dbg,-dev}_1.8.0.1-1_amd64.deb
-    $ wget http://packages.couchbase.com/clients/c/libcouchbase{1,1-dbg,-dev}_1.0.0-1_amd64.deb
+    # Ubuntu 11.10 Oneiric Ocelot (Debian unstable)
+    deb http://packages.couchbase.com/ubuntu oneiric oneiric/main
 
-or
+    # Ubuntu 10.04 Lucid Lynx (Debian stable or testing)
+    deb http://packages.couchbase.com/ubuntu lucid lucid/main
 
-    $ wget http://packages.couchbase.com/clients/c/libvbucket{1,1-dbg,-dev}_1.8.0.1-1_i386.deb
-    $ wget http://packages.couchbase.com/clients/c/libcouchbase{1,1-dbg,-dev}_1.0.0-1_i386.deb
+Import Couchbase PGP key:
 
-Then install them using dpkg tool
+    wget -O- http://packages.couchbase.com/ubuntu/couchbase.key | sudo apt-key add -
 
-    $ sudo dpkg -i lib{vbucket,couchbase}*.deb
+Then install them
+
+    $ sudo apt-get update && sudo apt-get install libcouchbase-dev
 
 ### Centos (Redhat and rpm-based systems)
 
-Download packages depending on your architecture:
+Add these lines to /etc/yum.repos.d/couchbase.repo using the correct architecture
+
+    [couchbase]
+    name = Couchbase package repository
+    baseurl = http://packages.couchbase.com/rpm/5.5/i386
 
-    $ wget http://packages.couchbase.com/clients/c/libvbucket{1,-debuginfo,-devel}-1.8.0.1-1.x86_64.rpm
-    $ wget http://packages.couchbase.com/clients/c/libcouchbase{1,-debuginfo,-devel}-1.0.0-1.x86_64.rpm
+    [couchbase]
+    name = Couchbase package repository
+    baseurl = http:///packages.couchbase.com/rpm/5.5/x86_64
 
-or
+Then to install libcouchbase itself, run:
 
-    $ wget http://packages.couchbase.com/clients/c/libvbucket{1,-debuginfo,-devel}-1.8.0.1-1.i386.rpm
-    $ wget http://packages.couchbase.com/clients/c/libcouchbase{1,-debuginfo,-devel}-1.0.0-1.i386.rpm
+    $ sudo yum update && sudo yum install libcouchbase-devel
 
-Then install them using rpm tool
+### Windows
 
-    $ sudo rpm -ivh lib{vbucket,couchbase}*.rpm
+There no additional dependencies for Windows systems. The gem carry
+prebuilt binary for it.
 
 ### Couchbase gem
 
@@ -61,7 +69,6 @@ Now install the couchbase gem itself
 
     $ gem install couchbase
 
-
 ## USAGE
 
 First of all you need to load library:
@@ -87,20 +94,13 @@ This is equivalent to following forms:
 
 The hash parameters take precedence on string URL.
 
-The library supports both synchronous and asynchronous mode. You can
-choose either using the `:async` option or attribute.
-
-    c = Couchbase.new(:async => true)
-    # ... asynchronous mode
-    c.async = false
-    # ... synchronous mode
-
-In asynchronous mode all operations will return control to caller
+The library supports both synchronous and asynchronous mode. In
+asynchronous mode all operations will return control to caller
 without blocking current thread. You can pass the block to method and it
 will be called with result when the operation will be completed. You
 need to run event loop when you scheduled your operations:
 
-    c = Couchbase.new(:async => true)
+    c = Couchbase.new
     c.run do |conn|
       conn.get("foo") {|ret| puts ret.value}
       conn.set("bar", "baz")
@@ -139,10 +139,10 @@ To handle global errors in async mode `#on_error` callback should be
 used. It can be set in following fashions:
 
     c.on_error do |opcode, key, exc|
-      ...
+      # ...
     end
 
-    handler = lambda {|opcode, key, exc| ...}
+    handler = lambda {|opcode, key, exc| }
     c.on_error = handler
 
 By default connection uses `:quiet` mode. This mean it won't raise
@@ -156,7 +156,7 @@ You can turn on these exception by passing `:quiet => false` when you
 are instantiating the connection or change corresponding attribute:
 
     c.quiet = false
-    c.get("missing-key")            #=> raise Couchbase::Error::NotFound
+    c.get("missing-key")                    #=> raise Couchbase::Error::NotFound
     c.get("missing-key", :quiet => true)    #=> nil
 
 The library supports three different formats for representing values:
@@ -174,7 +174,7 @@ The library supports three different formats for representing values:
 * `:plain` Use this format if you'd like to transparently serialize your
   ruby object with standard `Marshal.dump` and `Marshal.load` methods
 
-The couchbase API is the superset of [Memcached binary protocol][4], so
+The couchbase API is the superset of [Memcached binary protocol][5], so
 you can use its operations.
 
 ### Get
@@ -190,8 +190,17 @@ Get multiple values. In quiet mode will put `nil` values on missing
 positions:
 
     vals = c.get("foo", "bar", "baz")
-    c.get("foo"){|val, key| ... }
-    c.get("foo", :extended => true){|val, key, flags, cas| ... }
+    val_foo, val_bar, val_baz = c.get("foo", "bar", "baz")
+    c.run do
+      c.get("foo") do |ret|
+        ret.success?
+        ret.error
+        ret.key
+        ret.value
+        ret.flags
+        ret.cas
+      end
+    end
 
 Get multiple values with extended information. The result will
 represented by hash with tuples `[value, flags, cas]` as a value.
@@ -214,7 +223,7 @@ Hash-like syntax
     c.touch("foo", 10)
     c.touch("foo", :ttl => 10)
     c.touch("foo" => 10, "bar" => 20)
-    c.touch("foo" => 10, "bar" => 20){|key, success| ... }
+    c.touch("foo" => 10, "bar" => 20){|key, success|  }
 
 ### Set
 
@@ -222,9 +231,9 @@ Hash-like syntax
     c.set("foo", "bar", :flags => 0x1000, :ttl => 30, :format => :plain)
     c["foo"] = "bar"
     c["foo", {:flags => 0x1000, :format => :plain}] = "bar"
-    c["foo", :flags => 0x1000] = "bar"  # for ruby 1.9.x only
+    c["foo", :flags => 0x1000] = "bar"          # for ruby 1.9.x only
     c.set("foo", "bar", :cas => 8835713818674332672)
-    c.set("foo", "bar"){|cas, key, operation| ... }
+    c.set("foo", "bar"){|cas, key, operation|  }
 
 ### Add
 
@@ -264,12 +273,24 @@ Couchbase::Error::DeltaBadval if the delta or value is not a number.
     c.incr("foo", 4)                #=> 8
     c.incr("foo", -1)               #=> 7
     c.incr("foo", -100)             #=> 0
-    c.incr("foo"){|val, cas| ... }
+    c.run do
+      c.incr("foo") do |ret|
+        ret.success?
+        ret.value
+        ret.cas
+      end
+    end
 
     c.set("foo", 10)
     c.decr("foo", 1)                #=> 9
     c.decr("foo", 100)              #=> 0
-    c.decr("foo"){|val, cas| ... }
+    c.run do
+      c.decr("foo") do |ret|
+        ret.success?
+        ret.value
+        ret.cas
+      end
+    end
 
     c.incr("missing1", :initial => 10)      #=> 10
     c.incr("missing1", :initial => 10)      #=> 11
@@ -287,21 +308,39 @@ performed on client side with following `set` operation:
     c.delete("foo")
     c.delete("foo", :cas => 8835713818674332672)
     c.delete("foo", 8835713818674332672)
-    c.delete{|key, success| ... }
+    c.run do
+      c.delete do |ret|
+        ret.success?
+        ret.key
+      end
+    end
 
 ### Flush
 
 Flush the items in the cluster.
 
     c.flush
-    c.flush{|node, success| ... }
+    c.run do
+      c.flush do |ret|
+        ret.success?
+        ret.node
+      end
+    end
 
 ### Stats
 
 Return statistics from each node in the cluster
 
     c.stats
-    c.stats{|node, key, value| ... }
+    c.stats(:memory)
+    c.run do
+      c.stats do |ret|
+        ret.success?
+        ret.node
+        ret.key
+        ret.value
+      end
+    end
 
 The result is represented as a hash with the server node address as
 the key and stats as key-value pairs.
@@ -312,19 +351,20 @@ the key and stats as key-value pairs.
           "threads"=>"4",
           "connection_structures"=>"22",
           "ep_max_txn_size"=>"10000",
-          ...
+          # ...
         },
       "172.16.16.76:12000"=>
         {
           "threads"=>"4",
           "connection_structures"=>"447",
           "ep_max_txn_size"=>"10000",
-          ...
+          # ...
         },
-      ...
+      # ...
     }
 
-[1]: https://github.com/brianmario/yajl-ruby/
-[2]: http://lloyd.github.com/yajl/
+[1]: http://couchbase.com/issues/browse/RCBC
+[2]: http://freenode.net/irc_servers.shtml
 [3]: http://www.couchbase.com/develop/c/current
-[4]: http://code.google.com/p/memcached/wiki/BinaryProtocolRevamped
+[4]: https://github.com/mxcl/homebrew/pulls/avsej
+[5]: http://code.google.com/p/memcached/wiki/BinaryProtocolRevamped

data/couchbase.gemspec

@@ -42,5 +42,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake-compiler', '>= 0.7.5'
   s.add_development_dependency 'rdiscount'
   s.add_development_dependency 'yard'
+  s.add_development_dependency 'mini_portile'
   s.add_development_dependency RUBY_VERSION =~ /^1\.9/ ? 'ruby-debug19' : 'ruby-debug'
 end

data/ext/couchbase_ext/couchbase_ext.c

@@ -20,8 +20,8 @@
 #include <st.h>
 #endif
 
+#include <time.h>
 #include <libcouchbase/couchbase.h>
-#include <event.h>
 #include "couchbase_config.h"
 
 #ifdef HAVE_STDARG_PROTOTYPES
@@ -60,7 +60,8 @@ typedef struct
     long seqno;
     VALUE default_format;    /* should update +default_flags+ on change */
     uint32_t default_flags;
-    uint32_t default_ttl;
+    time_t default_ttl;
+    uint32_t timeout;
     VALUE exception;        /* error delivered by error_callback */
     VALUE on_error_proc;    /* is using to deliver errors in async mode */
 } bucket_t;
@@ -81,14 +82,15 @@ struct key_traits
     VALUE keys_ary;
     size_t nkeys;
     char **keys;
-    size_t *lens;
+    libcouchbase_size_t *lens;
     time_t *ttls;
     int extended;
     int explicit_ttl;
     int quiet;
+    int mgat;
 };
 
-static VALUE mCouchbase, mError, mJSON, mMarshal, cBucket, cResult;
+static VALUE mCouchbase, mError, mJSON, mURI, mMarshal, cBucket, cResult;
 static VALUE object_space;
 
 static ID  sym_add,
@@ -99,6 +101,7 @@ static ID  sym_add,
            sym_decrement,
            sym_default_flags,
            sym_default_format,
+           sym_default_ttl,
            sym_delete,
            sym_document,
            sym_extended,
@@ -119,35 +122,33 @@ static ID  sym_add,
            sym_replace,
            sym_set,
            sym_stats,
+           sym_timeout,
            sym_touch,
            sym_ttl,
            sym_username,
+           sym_version,
            id_arity,
            id_call,
            id_dump,
            id_flatten_bang,
            id_has_key_p,
-           id_load,
-           id_to_s,
-           id_iv_authority,
-           id_iv_bucket,
+           id_host,
            id_iv_cas,
-           id_iv_default_flags,
-           id_iv_default_format,
            id_iv_error,
            id_iv_flags,
-           id_iv_hostname,
            id_iv_key,
            id_iv_node,
-           id_iv_on_error,
            id_iv_operation,
-           id_iv_password,
-           id_iv_pool,
-           id_iv_port,
-           id_iv_quiet,
-           id_iv_url,
-           id_iv_username,
-           id_iv_value;
+           id_iv_value,
+           id_load,
+           id_match,
+           id_parse,
+           id_password,
+           id_path,
+           id_port,
+           id_scheme,
+           id_to_s,
+           id_user;
 
 /* base error */
 static VALUE eBaseError;
@@ -176,6 +177,9 @@ static VALUE eNotSupportedError;       /*LIBCOUCHBASE_NOT_SUPPORTED = 0x12*/
 static VALUE eUnknownCommandError;     /*LIBCOUCHBASE_UNKNOWN_COMMAND = 0x13*/
 static VALUE eUnknownHostError;        /*LIBCOUCHBASE_UNKNOWN_HOST = 0x14*/
 static VALUE eProtocolError;           /*LIBCOUCHBASE_PROTOCOL_ERROR = 0x15*/
+static VALUE eTimeoutError;            /*LIBCOUCHBASE_ETIMEDOUT = 0x16*/
+static VALUE eConnectError;            /*LIBCOUCHBASE_CONNECT_ERROR = 0x17*/
+static VALUE eBucketNotFoundError;     /*LIBCOUCHBASE_BUCKET_ENOENT = 0x18*/
 
     static VALUE
 cb_proc_call(VALUE recv, int argc, ...)
@@ -274,6 +278,16 @@ cb_check_error(libcouchbase_error_t rc, const char *msg, VALUE key)
             break;
         case LIBCOUCHBASE_PROTOCOL_ERROR:
             klass = eProtocolError;
+            break;
+        case LIBCOUCHBASE_ETIMEDOUT:
+            klass = eTimeoutError;
+            break;
+        case LIBCOUCHBASE_CONNECT_ERROR:
+            klass = eConnectError;
+            break;
+        case LIBCOUCHBASE_BUCKET_ENOENT:
+            klass = eBucketNotFoundError;
+            break;
         case LIBCOUCHBASE_ERROR:
             /* fall through */
         default:
@@ -286,7 +300,7 @@ cb_check_error(libcouchbase_error_t rc, const char *msg, VALUE key)
         snprintf(buf, 300, "key=\"%s\", ", RSTRING_PTR(key));
         rb_str_buf_cat2(str, buf);
     }
-    snprintf(buf, 300, "error=0x%x)", rc);
+    snprintf(buf, 300, "error=0x%02x)", rc);
     rb_str_buf_cat2(str, buf);
     exc = rb_exc_new3(klass, str);
     rb_ivar_set(exc, id_iv_error, INT2FIX(rc));
@@ -433,44 +447,20 @@ cb_extract_keys_i(VALUE key, VALUE value, VALUE arg)
     static long
 cb_args_scan_keys(long argc, VALUE argv, bucket_t *bucket, struct key_traits *traits)
 {
-    VALUE arg, key, *keys_ptr, opts, ttl, ext;
+    VALUE key, *keys_ptr, opts, ttl, ext;
     long nn = 0, ii;
     time_t exp;
 
     traits->keys_ary = rb_ary_new();
     traits->quiet = bucket->quiet;
-    if (argc == 1) {
-        arg = RARRAY_PTR(argv)[0];
-        switch (TYPE(arg)) {
-            case T_HASH:
-                /* hash of key-ttl pairs */
-                nn = RHASH_SIZE(arg);
-                traits->keys = calloc(nn, sizeof(char *));
-                traits->lens = calloc(nn, sizeof(size_t));
-                traits->explicit_ttl = 1;
-                traits->ttls = calloc(nn, sizeof(time_t));
-                rb_hash_foreach(arg, cb_extract_keys_i, (VALUE)traits);
-                break;
-            case T_STRING:
-            case T_SYMBOL:
-                /* single key with default expiration */
-                nn = traits->nkeys = 1;
-                traits->keys = calloc(nn, sizeof(char *));
-                traits->lens = calloc(nn, sizeof(size_t));
-                traits->ttls = calloc(nn, sizeof(time_t));
-                key = unify_key(arg);
-                rb_ary_push(traits->keys_ary, key);
-                traits->keys[0] = RSTRING_PTR(key);
-                traits->lens[0] = RSTRING_LEN(key);
-                traits->ttls[0] = bucket->default_ttl;
-                break;
-        }
-    } else if (argc > 1) {
+    traits->mgat = 0;
+
+    if (argc > 0) {
         /* keys with custom options */
         opts = RARRAY_PTR(argv)[argc-1];
         exp = bucket->default_ttl;
         ext = Qfalse;
-        if (TYPE(opts) == T_HASH) {
+        if (argc > 1 && TYPE(opts) == T_HASH) {
             (void)rb_ary_pop(argv);
             if (RTEST(rb_funcall(opts, id_has_key_p, 1, sym_quiet))) {
                 traits->quiet = RTEST(rb_hash_aref(opts, sym_quiet));
@@ -488,18 +478,30 @@ cb_args_scan_keys(long argc, VALUE argv, bucket_t *bucket, struct key_traits *tr
         if (nn < 1) {
             rb_raise(rb_eArgError, "must be at least one key");
         }
-        traits->nkeys = nn;
-        traits->extended = RTEST(ext) ? 1 : 0;
-        traits->keys = calloc(nn, sizeof(char *));
-        traits->lens = calloc(nn, sizeof(size_t));
-        traits->ttls = calloc(nn, sizeof(time_t));
         keys_ptr = RARRAY_PTR(argv);
-        for (ii = 0; ii < nn; ii++) {
-            key = unify_key(keys_ptr[ii]);
-            rb_ary_push(traits->keys_ary, key);
-            traits->keys[ii] = RSTRING_PTR(key);
-            traits->lens[ii] = RSTRING_LEN(key);
-            traits->ttls[ii] = exp;
+        traits->extended = RTEST(ext) ? 1 : 0;
+        if (nn == 1 && TYPE(keys_ptr[0]) == T_HASH) {
+            /* hash of key-ttl pairs */
+            nn = RHASH_SIZE(keys_ptr[0]);
+            traits->keys = calloc(nn, sizeof(char *));
+            traits->lens = calloc(nn, sizeof(size_t));
+            traits->explicit_ttl = 1;
+            traits->mgat = 1;
+            traits->ttls = calloc(nn, sizeof(time_t));
+            rb_hash_foreach(keys_ptr[0], cb_extract_keys_i, (VALUE)traits);
+        } else {
+            /* the list of keys */
+            traits->nkeys = nn;
+            traits->keys = calloc(nn, sizeof(char *));
+            traits->lens = calloc(nn, sizeof(size_t));
+            traits->ttls = calloc(nn, sizeof(time_t));
+            for (ii = 0; ii < nn; ii++) {
+                key = unify_key(keys_ptr[ii]);
+                rb_ary_push(traits->keys_ary, key);
+                traits->keys[ii] = RSTRING_PTR(key);
+                traits->lens[ii] = RSTRING_LEN(key);
+                traits->ttls[ii] = exp;
+            }
         }
     }
 
@@ -518,7 +520,7 @@ error_callback(libcouchbase_t handle, libcouchbase_error_t error, const char *er
     static void
 storage_callback(libcouchbase_t handle, const void *cookie,
         libcouchbase_storage_t operation, libcouchbase_error_t error,
-        const void *key, size_t nkey, uint64_t cas)
+        const void *key, libcouchbase_size_t nkey, libcouchbase_cas_t cas)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -578,7 +580,8 @@ storage_callback(libcouchbase_t handle, const void *cookie,
 
     static void
 delete_callback(libcouchbase_t handle, const void *cookie,
-        libcouchbase_error_t error, const void *key, size_t nkey)
+        libcouchbase_error_t error, const void *key,
+        libcouchbase_size_t nkey)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -616,8 +619,10 @@ delete_callback(libcouchbase_t handle, const void *cookie,
 
     static void
 get_callback(libcouchbase_t handle, const void *cookie,
-        libcouchbase_error_t error, const void *key, size_t nkey,
-        const void *bytes, size_t nbytes, uint32_t flags, uint64_t cas)
+        libcouchbase_error_t error, const void *key,
+        libcouchbase_size_t nkey, const void *bytes,
+        libcouchbase_size_t nbytes, libcouchbase_uint32_t flags,
+        libcouchbase_cas_t cas)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -645,7 +650,11 @@ get_callback(libcouchbase_t handle, const void *cookie,
             v = Qnil;
         }
     } else {
-        v = Qnil;
+        if (flags_get_format(flags) == sym_plain) {
+            v = rb_str_new2("");
+        } else {
+            v = Qnil;
+        }
     }
     if (bucket->async) { /* asynchronous */
         if (ctx->proc != Qnil) {
@@ -659,7 +668,7 @@ get_callback(libcouchbase_t handle, const void *cookie,
             cb_proc_call(ctx->proc, 1, res);
         }
     } else {                /* synchronous */
-        if (NIL_P(exc) && v != Qnil) {
+        if (NIL_P(exc) && error != LIBCOUCHBASE_KEY_ENOENT) {
             if (ctx->extended) {
                 rb_hash_aset(*rv, k, rb_ary_new3(3, v, f, c));
             } else {
@@ -716,13 +725,59 @@ flush_callback(libcouchbase_t handle, const void* cookie,
         }
     }
 
+    (void)handle;
+}
+
+    static void
+version_callback(libcouchbase_t handle, const void *cookie,
+        const char *authority, libcouchbase_error_t error,
+        const char *bytes, libcouchbase_size_t nbytes)
+{
+    context_t *ctx = (context_t *)cookie;
+    bucket_t *bucket = ctx->bucket;
+    VALUE node, v, *rv = ctx->rv, exc, res;
+
+    node = authority ? rb_str_new2(authority) : Qnil;
+    exc = cb_check_error(error, "failed to get version", node);
+    if (exc != Qnil) {
+        rb_ivar_set(exc, id_iv_operation, sym_flush);
+        if (NIL_P(ctx->exception)) {
+            ctx->exception = exc;
+        }
+    }
+
+    if (authority) {
+        v = rb_str_new((const char*)bytes, nbytes);
+        if (bucket->async) {    /* asynchronous */
+            if (ctx->proc != Qnil) {
+                res = rb_class_new_instance(0, NULL, cResult);
+                rb_ivar_set(res, id_iv_error, exc);
+                rb_ivar_set(res, id_iv_operation, sym_version);
+                rb_ivar_set(res, id_iv_node, node);
+                rb_ivar_set(res, id_iv_value, v);
+                cb_proc_call(ctx->proc, 1, res);
+            }
+        } else {                /* synchronous */
+            if (NIL_P(exc)) {
+                rb_hash_aset(*rv, node, v);
+            }
+        }
+    } else {
+        bucket->seqno--;
+        if (bucket->seqno == 0) {
+            bucket->io->stop_event_loop(bucket->io);
+            rb_hash_delete(object_space, ctx->proc|1);
+        }
+    }
+
     (void)handle;
 }
 
     static void
 stat_callback(libcouchbase_t handle, const void* cookie,
         const char* authority, libcouchbase_error_t error, const void* key,
-        size_t nkey, const void* bytes, size_t nbytes)
+        libcouchbase_size_t nkey, const void* bytes,
+        libcouchbase_size_t nbytes)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -751,12 +806,12 @@ stat_callback(libcouchbase_t handle, const void* cookie,
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
-                stats = rb_hash_aref(*rv, node);
+                stats = rb_hash_aref(*rv, k);
                 if (NIL_P(stats)) {
                     stats = rb_hash_new();
-                    rb_hash_aset(*rv, node, stats);
+                    rb_hash_aset(*rv, k, stats);
                 }
-                rb_hash_aset(stats, k, v);
+                rb_hash_aset(stats, node, v);
             }
         }
     } else {
@@ -771,7 +826,8 @@ stat_callback(libcouchbase_t handle, const void* cookie,
 
     static void
 touch_callback(libcouchbase_t handle, const void *cookie,
-        libcouchbase_error_t error, const void *key, size_t nkey)
+        libcouchbase_error_t error, const void *key,
+        libcouchbase_size_t nkey)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -800,7 +856,7 @@ touch_callback(libcouchbase_t handle, const void *cookie,
     } else {                /* synchronous */
         if (NIL_P(exc)) {
             success = (error == LIBCOUCHBASE_KEY_ENOENT) ? Qfalse : Qtrue;
-            rb_ary_push(*rv, success);
+            rb_hash_aset(*rv, k, success);
         }
     }
     if (bucket->seqno == 0) {
@@ -812,8 +868,9 @@ touch_callback(libcouchbase_t handle, const void *cookie,
 
     static void
 arithmetic_callback(libcouchbase_t handle, const void *cookie,
-        libcouchbase_error_t error, const void *key, size_t nkey,
-        uint64_t value, uint64_t cas)
+        libcouchbase_error_t error, const void *key,
+        libcouchbase_size_t nkey, libcouchbase_uint64_t value,
+        libcouchbase_cas_t cas)
 {
     context_t *ctx = (context_t *)cookie;
     bucket_t *bucket = ctx->bucket;
@@ -869,79 +926,6 @@ arithmetic_callback(libcouchbase_t handle, const void *cookie,
     (void)handle;
 }
 
-    static char *
-parse_path_segment(char *source, const char *key, char **result)
-{
-    size_t len;
-    char *eot;
-
-    if (source == NULL) {
-        return NULL;
-    }
-    eot = strchr(source, '/');
-    if (eot > source && strncmp(source, key, eot - source) == 0) {
-        *eot = '\0';
-        source = eot + 1;
-        eot = strchr(source, '/');
-        len = strlen(source);
-        if (eot > source || len) {
-            if (eot) {
-                *eot = '\0';
-                eot++;
-            }
-            *result = strdup(source);
-        }
-    }
-    return eot;
-}
-
-    static void
-parse_bucket_uri(VALUE uri, bucket_t *bucket)
-{
-    char *src, *ptr, *eot, sep = '\0';
-
-    ptr = src = strdup(StringValueCStr(uri));
-    eot = strchr(ptr, ':');
-    if (eot < ptr || strncmp(ptr, "http", eot - ptr) != 0) {
-        free(src);
-        rb_raise(rb_eArgError, "invalid URI format: missing schema");
-        return;
-    }
-    ptr = eot + 1;
-    if (ptr[0] != '/' || ptr[1] != '/') {
-        free(src);
-        rb_raise(rb_eArgError, "invalid URI format.");
-        return;
-    }
-    ptr += 2;
-    eot = ptr;
-    while (*eot) {
-        if (*eot == '?' || *eot == '#' || *eot == ':' || *eot == '/') {
-            break;
-        }
-        ++eot;
-    }
-    if (eot > ptr) {
-        sep = *eot;
-        *eot = '\0';
-        bucket->hostname = strdup(ptr);
-    }
-    ptr = eot + 1;
-    eot = strchr(ptr, '/');
-    if (sep == ':') {
-        if (eot > ptr) {
-            *eot = '\0';
-        }
-        bucket->port = (uint16_t)atoi(ptr);
-        if (eot > ptr) {
-            ptr = eot + 1;
-        }
-    }
-    ptr = parse_path_segment(ptr, "pools", &bucket->pool);
-    parse_path_segment(ptr, "buckets", &bucket->bucket);
-    free(src);
-}
-
     static int
 cb_first_value_i(VALUE key, VALUE value, VALUE arg)
 {
@@ -952,28 +936,8 @@ cb_first_value_i(VALUE key, VALUE value, VALUE arg)
     return ST_STOP;
 }
 
-    static VALUE
-cb_bucket_inspect(VALUE self)
-{
-    VALUE str;
-    bucket_t *bucket = DATA_PTR(self);
-    char buf[200];
-
-    str = rb_str_buf_new2("#<");
-    rb_str_buf_cat2(str, rb_obj_classname(self));
-    snprintf(buf, 25, ":%p \"", (void *)self);
-    rb_str_buf_cat2(str, buf);
-    rb_str_append(str, rb_ivar_get(self, id_iv_url));
-    snprintf(buf, 150, "\" default_format=:%s, default_flags=0x%x, quiet=%s>",
-            rb_id2name(SYM2ID(bucket->default_format)),
-            bucket->default_flags,
-            bucket->quiet ? "true" : "false");
-    rb_str_buf_cat2(str, buf);
-
-    return str;
-}
-
 /*
+ * @private
  * @return [Fixnum] number of scheduled operations
  */
     static VALUE
@@ -992,13 +956,13 @@ cb_bucket_free(void *ptr)
     if (bucket) {
         if (bucket->handle) {
             libcouchbase_destroy(bucket->handle);
-            free(bucket->authority);
-            free(bucket->hostname);
-            free(bucket->pool);
-            free(bucket->bucket);
-            free(bucket->username);
-            free(bucket->password);
         }
+        free(bucket->authority);
+        free(bucket->hostname);
+        free(bucket->pool);
+        free(bucket->bucket);
+        free(bucket->username);
+        free(bucket->password);
         free(bucket);
     }
 }
@@ -1014,97 +978,69 @@ cb_bucket_mark(void *ptr)
     }
 }
 
-/*
- * @return [Bucket] new instance (see Bucket#initialize)
- */
-    static VALUE
-cb_bucket_new(int argc, VALUE *argv, VALUE klass)
-{
-    VALUE obj;
-    bucket_t *bucket;
-
-    /* allocate new bucket struct and set it to zero */
-    obj = Data_Make_Struct(klass, bucket_t, cb_bucket_mark, cb_bucket_free,
-            bucket);
-    rb_obj_call_init(obj, argc, argv);
-    return obj;
-}
-
-/*
- * @overload initialize(url, options = {})
- *   Initialize bucket using URI of the cluster and options. It is possible
- *   to override some parts of URI using the options keys (e.g. :host or
- *   :port)
- *
- *   @param [String] url The full URL of management API of the cluster.
- *   @param [Hash] options The options for connection. See options definition
- *     below.
- *
- * @overload initialize(options = {})
- *   Initialize bucket using options only.
- *
- *   @param [Hash] options The options for operation for connection
- *   @option options [String] :host ("localhost") the hostname or IP address
- *     of the node
- *   @option options [Fixnum] :port (8091) the port of the managemenent API
- *   @option options [String] :pool ("default") the pool name
- *   @option options [String] :bucket ("default") the bucket name
- *   @option options [Fixnum] :default_ttl (0) the TTL used by default during
- *     storing key-value pairs.
- *   @option options [Fixnum] :default_flags (0) the default flags.
- *   @option options [Symbol] :default_format (:document) the format, which
- *     will be used for values by default. Note that changing format will
- *     amend flags. (see Bucket#default_format)
- *   @option options [String] :username (nil) the user name to connect to the
- *     cluster. Used to authenticate on management API.
- *   @option options [String] :password (nil) the password of the user.
- *   @option options [Boolean] :quiet (true) the flag controlling if raising
- *     exception when the client executes operations on unexising keys. If it
- *     is +true+ it will raise +Couchbase::NotFoundError+ exceptions. The
- *     default behaviour is to return +nil+ value silently (might be useful in
- *     Rails cache).
- *
- * @example Initialize connection using default options
- *   Couchbase.new
- *
- * @example Select custom bucket
- *   Couchbase.new(:bucket => 'foo')
- *   Couchbase.new('http://localhost:8091/pools/default/buckets/foo')
- *
- * @example Connect to protected bucket
- *   Couchbase.new(:bucket => 'protected', :username => 'protected', :password => 'secret')
- *   Couchbase.new('http://localhost:8091/pools/default/buckets/protected',
- *                 :username => 'protected', :password => 'secret')
- *
- * @return [Bucket]
- */
-    static VALUE
-cb_bucket_init(int argc, VALUE *argv, VALUE self)
+    static void
+do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
 {
-    VALUE uri, opts, arg, buf;
-    libcouchbase_error_t err;
-    bucket_t *bucket = DATA_PTR(self);
+    VALUE uri, opts, arg;
     size_t len;
 
-    bucket->exception = Qnil;
-    bucket->hostname = strdup("localhost");
-    bucket->port = 8091;
-    bucket->pool = strdup("default");
-    bucket->bucket = strdup("default");
-    bucket->async = 0;
-    bucket->quiet = 1;
-    bucket->default_flags = 0;
-    bucket->default_format = sym_document;
-    bucket->on_error_proc = Qnil;
-
     if (rb_scan_args(argc, argv, "02", &uri, &opts) > 0) {
         if (TYPE(uri) == T_HASH && argc == 1) {
             opts = uri;
             uri = Qnil;
         }
         if (uri != Qnil) {
+            const char path_re[] = "^(/pools/([A-Za-z0-9_.-]+)(/buckets/([A-Za-z0-9_.-]+))?)?";
+            VALUE match, uri_obj, re;
+
             Check_Type(uri, T_STRING);
-            parse_bucket_uri(uri, bucket);
+            uri_obj = rb_funcall(mURI, id_parse, 1, uri);
+
+            arg = rb_funcall(uri_obj, id_scheme, 0);
+            if (arg == Qnil || rb_str_cmp(arg, rb_str_new2("http"))) {
+                rb_raise(rb_eArgError, "invalid URI: invalid scheme");
+            }
+
+            arg = rb_funcall(uri_obj, id_user, 0);
+            if (arg != Qnil) {
+                free(bucket->username);
+                bucket->username = strdup(RSTRING_PTR(arg));
+                if (bucket->username == NULL) {
+                    rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
+                }
+            }
+
+            arg = rb_funcall(uri_obj, id_password, 0);
+            if (arg != Qnil) {
+                free(bucket->password);
+                bucket->password = strdup(RSTRING_PTR(arg));
+                if (bucket->password == NULL) {
+                    rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
+                }
+            }
+            arg = rb_funcall(uri_obj, id_host, 0);
+            if (arg != Qnil) {
+                free(bucket->hostname);
+                bucket->hostname = strdup(RSTRING_PTR(arg));
+                if (bucket->hostname == NULL) {
+                    rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
+                }
+            } else {
+                rb_raise(rb_eArgError, "invalid URI: missing hostname");
+            }
+
+            arg = rb_funcall(uri_obj, id_port, 0);
+            bucket->port = NIL_P(arg) ? 8091 : (uint16_t)NUM2UINT(arg);
+
+            arg = rb_funcall(uri_obj, id_path, 0);
+            re = rb_reg_new(path_re, sizeof(path_re) - 1, 0);
+            match = rb_funcall(re, id_match, 1, arg);
+            arg = rb_reg_nth_match(2, match);
+            free(bucket->pool);
+            bucket->pool = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
+            arg = rb_reg_nth_match(4, match);
+            free(bucket->bucket);
+            bucket->bucket = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
         }
         if (TYPE(opts) == T_HASH) {
             arg = rb_hash_aref(opts, sym_hostname);
@@ -1130,10 +1066,16 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
             }
             arg = rb_hash_aref(opts, sym_username);
             if (arg != Qnil) {
+                if (bucket->username) {
+                    free(bucket->username);
+                }
                 bucket->username = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_password);
             if (arg != Qnil) {
+                if (bucket->password) {
+                    free(bucket->password);
+                }
                 bucket->password = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_port);
@@ -1143,6 +1085,14 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
             if (RTEST(rb_funcall(opts, id_has_key_p, 1, sym_quiet))) {
                 bucket->quiet = RTEST(rb_hash_aref(opts, sym_quiet));
             }
+            arg = rb_hash_aref(opts, sym_timeout);
+            if (arg != Qnil) {
+                bucket->timeout = (uint32_t)NUM2ULONG(arg);
+            }
+            arg = rb_hash_aref(opts, sym_default_ttl);
+            if (arg != Qnil) {
+                bucket->default_ttl = (uint32_t)NUM2ULONG(arg);
+            }
             arg = rb_hash_aref(opts, sym_default_flags);
             if (arg != Qnil) {
                 bucket->default_flags = (uint32_t)NUM2ULONG(arg);
@@ -1172,13 +1122,28 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
         }
     }
     len = strlen(bucket->hostname) + 10;
+    if (bucket->authority) {
+        free(bucket->authority);
+    }
     bucket->authority = calloc(len, sizeof(char));
     if (bucket->authority == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
     }
     snprintf(bucket->authority, len, "%s:%u", bucket->hostname, bucket->port);
+}
+
+    static void
+do_connect(bucket_t *bucket)
+{
+    libcouchbase_error_t err;
+
+    if (bucket->handle) {
+        libcouchbase_destroy(bucket->handle);
+        bucket->handle = NULL;
+        bucket->io = NULL;
+    }
     bucket->io = libcouchbase_create_io_ops(LIBCOUCHBASE_IO_OPS_DEFAULT, NULL, &err);
-    if (bucket->io == NULL) {
+    if (bucket->io == NULL && err != LIBCOUCHBASE_SUCCESS) {
         rb_exc_raise(cb_check_error(err, "failed to create IO instance", Qnil));
     }
     bucket->handle = libcouchbase_create(bucket->authority,
@@ -1195,78 +1160,241 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     (void)libcouchbase_set_stat_callback(bucket->handle, stat_callback);
     (void)libcouchbase_set_flush_callback(bucket->handle, flush_callback);
     (void)libcouchbase_set_arithmetic_callback(bucket->handle, arithmetic_callback);
+    (void)libcouchbase_set_version_callback(bucket->handle, version_callback);
 
     err = libcouchbase_connect(bucket->handle);
     if (err != LIBCOUCHBASE_SUCCESS) {
+        libcouchbase_destroy(bucket->handle);
+        bucket->handle = NULL;
+        bucket->io = NULL;
         rb_exc_raise(cb_check_error(err, "failed to connect libcouchbase instance to server", Qnil));
     }
+    bucket->exception = Qnil;
     libcouchbase_wait(bucket->handle);
     if (bucket->exception != Qnil) {
+        libcouchbase_destroy(bucket->handle);
+        bucket->handle = NULL;
+        bucket->io = NULL;
         rb_exc_raise(bucket->exception);
     }
 
-    rb_ivar_set(self, id_iv_authority, rb_str_new2(bucket->authority));
-    rb_ivar_set(self, id_iv_bucket, rb_str_new2(bucket->bucket));
-    rb_ivar_set(self, id_iv_hostname, rb_str_new2(bucket->hostname));
-    rb_ivar_set(self, id_iv_password, bucket->password ? rb_str_new2(bucket->password) : Qnil);
-    rb_ivar_set(self, id_iv_pool, rb_str_new2(bucket->pool));
-    rb_ivar_set(self, id_iv_port, UINT2NUM(bucket->port));
-    rb_ivar_set(self, id_iv_username, bucket->username ? rb_str_new2(bucket->username) : Qnil);
-    rb_ivar_set(self, id_iv_quiet, bucket->quiet ? Qtrue : Qfalse);
-    rb_ivar_set(self, id_iv_default_flags, ULONG2NUM(bucket->default_flags));
-    rb_ivar_set(self, id_iv_default_format, bucket->default_format);
-    rb_ivar_set(self, id_iv_on_error, bucket->on_error_proc);
-
-    buf = rb_str_buf_new2("http://");
-    rb_str_buf_cat2(buf, bucket->authority);
-    rb_str_buf_cat2(buf, "/pools/");
-    rb_str_buf_cat2(buf, bucket->pool);
-    rb_str_buf_cat2(buf, "/buckets/");
-    rb_str_buf_cat2(buf, bucket->bucket);
-    rb_str_buf_cat2(buf, "/");
-    rb_ivar_set(self, id_iv_url, buf);
-
-    return self;
-}
-
-    static VALUE
-cb_bucket_async_p(VALUE self)
-{
-    bucket_t *bucket = DATA_PTR(self);
-    return bucket->async ? Qtrue : Qfalse;
-}
-
-    static VALUE
-cb_bucket_quiet_set(VALUE self, VALUE val)
-{
-    bucket_t *bucket = DATA_PTR(self);
-    VALUE new;
-
-    bucket->quiet = RTEST(val);
-    new = bucket->quiet ? Qtrue : Qfalse;
-    rb_ivar_set(self, id_iv_quiet, new);
-    return new;
+    if (bucket->timeout > 0) {
+        libcouchbase_set_timeout(bucket->handle, bucket->timeout);
+    } else {
+        bucket->timeout = libcouchbase_get_timeout(bucket->handle);
+    }
 }
 
+/*
+ * Create and initialize new Bucket.
+ *
+ * @return [Bucket] new instance
+ *
+ * @see Bucket#initialize
+ */
     static VALUE
-cb_bucket_default_flags_set(VALUE self, VALUE val)
+cb_bucket_new(int argc, VALUE *argv, VALUE klass)
 {
-    bucket_t *bucket = DATA_PTR(self);
+    VALUE obj;
+    bucket_t *bucket;
 
-    bucket->default_flags = (uint32_t)NUM2ULONG(val);
-    bucket->default_format = flags_get_format(bucket->default_flags);
-    rb_ivar_set(self, id_iv_default_format, bucket->default_format);
-    rb_ivar_set(self, id_iv_default_flags, val);
-    return val;
+    /* allocate new bucket struct and set it to zero */
+    obj = Data_Make_Struct(klass, bucket_t, cb_bucket_mark, cb_bucket_free,
+            bucket);
+    rb_obj_call_init(obj, argc, argv);
+    return obj;
 }
 
-    static VALUE
-cb_bucket_default_format_set(VALUE self, VALUE val)
-{
-    bucket_t *bucket = DATA_PTR(self);
-
-    if (TYPE(val) == T_FIXNUM) {
-        switch (FIX2INT(val)) {
+/*
+ * Initialize new Bucket.
+ *
+ * @overload initialize(url, options = {})
+ *   Initialize bucket using URI of the cluster and options. It is possible
+ *   to override some parts of URI using the options keys (e.g. :host or
+ *   :port)
+ *
+ *   @param [String] url The full URL of management API of the cluster.
+ *   @param [Hash] options The options for connection. See options definition
+ *     below.
+ *
+ * @overload initialize(options = {})
+ *   Initialize bucket using options only.
+ *
+ *   @param [Hash] options The options for operation for connection
+ *   @option options [String] :host ("localhost") the hostname or IP address
+ *     of the node
+ *   @option options [Fixnum] :port (8091) the port of the managemenent API
+ *   @option options [String] :pool ("default") the pool name
+ *   @option options [String] :bucket ("default") the bucket name
+ *   @option options [Fixnum] :default_ttl (0) the TTL used by default during
+ *     storing key-value pairs.
+ *   @option options [Fixnum] :default_flags (0) the default flags.
+ *   @option options [Symbol] :default_format (:document) the format, which
+ *     will be used for values by default. Note that changing format will
+ *     amend flags. (see {Bucket#default_format})
+ *   @option options [String] :username (nil) the user name to connect to the
+ *     cluster. Used to authenticate on management API.
+ *   @option options [String] :password (nil) the password of the user.
+ *   @option options [Boolean] :quiet (true) the flag controlling if raising
+ *     exception when the client executes operations on unexising keys. If it
+ *     is +true+ it will raise {Couchbase::Error::NotFound} exceptions. The
+ *     default behaviour is to return +nil+ value silently (might be useful in
+ *     Rails cache).
+ *
+ * @example Initialize connection using default options
+ *   Couchbase.new
+ *
+ * @example Select custom bucket
+ *   Couchbase.new(:bucket => 'foo')
+ *   Couchbase.new('http://localhost:8091/pools/default/buckets/foo')
+ *
+ * @example Connect to protected bucket
+ *   Couchbase.new(:bucket => 'protected', :username => 'protected', :password => 'secret')
+ *   Couchbase.new('http://localhost:8091/pools/default/buckets/protected',
+ *                 :username => 'protected', :password => 'secret')
+ *
+ * @return [Bucket]
+ */
+    static VALUE
+cb_bucket_init(int argc, VALUE *argv, VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+
+    bucket->exception = Qnil;
+    bucket->hostname = strdup("localhost");
+    bucket->port = 8091;
+    bucket->pool = strdup("default");
+    bucket->bucket = strdup("default");
+    bucket->async = 0;
+    bucket->quiet = 1;
+    bucket->default_ttl = 0;
+    bucket->default_flags = 0;
+    bucket->default_format = sym_document;
+    bucket->on_error_proc = Qnil;
+    bucket->timeout = 0;
+
+    do_scan_connection_options(bucket, argc, argv);
+    do_connect(bucket);
+
+    return self;
+}
+
+/*
+ * Reconnect the bucket
+ *
+ * Reconnect the bucket using initial configuration with optional
+ * redefinition.
+ *
+ * @overload reconnect(url, options = {})
+ *  see {Bucket#initialize Bucket#initialize(url, options)}
+ *
+ * @overload reconnect(options = {})
+ *  see {Bucket#initialize Bucket#initialize(options)}
+ *
+ *  @example reconnect with current parameters
+ *    c.reconnect
+ *
+ *  @example reconnect the instance to another bucket
+ *    c.reconnect(:bucket => 'new')
+ */
+    static VALUE
+cb_bucket_reconnect(int argc, VALUE *argv, VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+
+    do_scan_connection_options(bucket, argc, argv);
+    do_connect(bucket);
+
+    return self;
+}
+
+/* Document-method: connected?
+ * Check whether the instance connected to the cluster.
+ *
+ * @return [Boolean] +true+ if the instance connected to the cluster
+ */
+    static VALUE
+cb_bucket_connected_p(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return bucket->handle ? Qtrue : Qfalse;
+}
+
+/* Document-method: async?
+ * Check whether the connection asynchronous.
+ *
+ * By default all operations are synchronous and block waiting for
+ * results, but you can make them asynchronous and run event loop
+ * explicitly. (see {Bucket#run})
+ *
+ * @example Return value of #get operation depending on async flag
+ *   connection = Connection.new
+ *   connection.async?      #=> false
+ *
+ *   connection.run do |conn|
+ *     conn.async?          #=> true
+ *   end
+ *
+ * @return [Boolean] +true+ if the connection if asynchronous
+ *
+ * @see Bucket#run
+ */
+    static VALUE
+cb_bucket_async_p(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return bucket->async ? Qtrue : Qfalse;
+}
+
+    static VALUE
+cb_bucket_quiet_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return bucket->quiet ? Qtrue : Qfalse;
+}
+
+    static VALUE
+cb_bucket_quiet_set(VALUE self, VALUE val)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    VALUE new;
+
+    bucket->quiet = RTEST(val);
+    new = bucket->quiet ? Qtrue : Qfalse;
+    return new;
+}
+
+    static VALUE
+cb_bucket_default_flags_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return ULONG2NUM(bucket->default_flags);
+}
+
+    static VALUE
+cb_bucket_default_flags_set(VALUE self, VALUE val)
+{
+    bucket_t *bucket = DATA_PTR(self);
+
+    bucket->default_flags = (uint32_t)NUM2ULONG(val);
+    bucket->default_format = flags_get_format(bucket->default_flags);
+    return val;
+}
+
+    static VALUE
+cb_bucket_default_format_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return bucket->default_format;
+}
+
+    static VALUE
+cb_bucket_default_format_set(VALUE self, VALUE val)
+{
+    bucket_t *bucket = DATA_PTR(self);
+
+    if (TYPE(val) == T_FIXNUM) {
+        switch (FIX2INT(val)) {
             case FMT_DOCUMENT:
                 val = sym_document;
                 break;
@@ -1281,8 +1409,6 @@ cb_bucket_default_format_set(VALUE self, VALUE val)
     if (val == sym_document || val == sym_marshal || val == sym_plain) {
         bucket->default_format = val;
         bucket->default_flags = flags_set_format(bucket->default_flags, val);
-        rb_ivar_set(self, id_iv_default_format, val);
-        rb_ivar_set(self, id_iv_default_flags, ULONG2NUM(bucket->default_flags));
     }
 
     return val;
@@ -1298,7 +1424,6 @@ cb_bucket_on_error_set(VALUE self, VALUE val)
     } else {
         bucket->on_error_proc = Qnil;
     }
-    rb_ivar_set(self, id_iv_on_error, bucket->on_error_proc);
 
     return bucket->on_error_proc;
 }
@@ -1315,6 +1440,212 @@ cb_bucket_on_error_get(VALUE self)
     }
 }
 
+    static VALUE
+cb_bucket_timeout_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return ULONG2NUM(bucket->timeout);
+}
+
+    static VALUE
+cb_bucket_timeout_set(VALUE self, VALUE val)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    VALUE tmval;
+
+    bucket->timeout = (uint32_t)NUM2ULONG(val);
+    libcouchbase_set_timeout(bucket->handle, bucket->timeout);
+    tmval = ULONG2NUM(bucket->timeout);
+
+    return tmval;
+}
+
+/* Document-method: hostname
+ * @return [String] the host name of the management interface (default: "localhost")
+ */
+    static VALUE
+cb_bucket_hostname_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    if (bucket->handle) {
+        if (bucket->hostname) {
+            free(bucket->hostname);
+            bucket->hostname = NULL;
+        }
+        bucket->hostname = strdup(libcouchbase_get_host(bucket->handle));
+        if (bucket->hostname == NULL) {
+            rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
+        }
+    }
+    return rb_str_new2(bucket->hostname);
+}
+
+/* Document-method: port
+ * @return [Fixnum] the port number of the management interface (default: 8091)
+ */
+    static VALUE
+cb_bucket_port_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    if (bucket->handle) {
+        bucket->port = atoi(libcouchbase_get_port(bucket->handle));
+    }
+    return UINT2NUM(bucket->port);
+}
+
+/* Document-method: authority
+ * @return [String] host with port
+ */
+    static VALUE
+cb_bucket_authority_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    size_t len;
+
+    (void)cb_bucket_hostname_get(self);
+    (void)cb_bucket_port_get(self);
+    len = strlen(bucket->hostname) + 10;
+    bucket->authority = calloc(len, sizeof(char));
+    if (bucket->authority == NULL) {
+        rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
+    }
+    snprintf(bucket->authority, len, "%s:%u", bucket->hostname, bucket->port);
+    return rb_str_new2(bucket->authority);
+}
+
+/* Document-method: bucket
+ * @return [String] the bucket name
+ */
+    static VALUE
+cb_bucket_bucket_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return rb_str_new2(bucket->bucket);
+}
+
+/* Document-method: pool
+ * @return [String] the pool name (usually "default")
+ */
+    static VALUE
+cb_bucket_pool_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return rb_str_new2(bucket->pool);
+}
+
+/* Document-method: username
+ * @return [String] the username for protected buckets (usually matches
+ *   the bucket name)
+ */
+    static VALUE
+cb_bucket_username_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return rb_str_new2(bucket->username);
+}
+
+/* Document-method: password
+ * @return [String] the password for protected buckets
+ */
+    static VALUE
+cb_bucket_password_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    return rb_str_new2(bucket->password);
+}
+
+/* Document-method: url
+ * @return [String] the address of the cluster management interface
+ */
+    static VALUE
+cb_bucket_url_get(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    VALUE str;
+
+    (void)cb_bucket_authority_get(self);
+    str = rb_str_buf_new2("http://");
+    rb_str_buf_cat2(str, bucket->authority);
+    rb_str_buf_cat2(str, "/pools/");
+    rb_str_buf_cat2(str, bucket->pool);
+    rb_str_buf_cat2(str, "/buckets/");
+    rb_str_buf_cat2(str, bucket->bucket);
+    rb_str_buf_cat2(str, "/");
+    return str;
+}
+
+/*
+ * Returns a string containing a human-readable representation of the
+ * Bucket.
+ *
+ * @return [String]
+ */
+    static VALUE
+cb_bucket_inspect(VALUE self)
+{
+    VALUE str;
+    bucket_t *bucket = DATA_PTR(self);
+    char buf[200];
+
+    str = rb_str_buf_new2("#<");
+    rb_str_buf_cat2(str, rb_obj_classname(self));
+    snprintf(buf, 25, ":%p \"", (void *)self);
+    (void)cb_bucket_authority_get(self);
+    rb_str_buf_cat2(str, buf);
+    rb_str_buf_cat2(str, "http://");
+    rb_str_buf_cat2(str, bucket->authority);
+    rb_str_buf_cat2(str, "/pools/");
+    rb_str_buf_cat2(str, bucket->pool);
+    rb_str_buf_cat2(str, "/buckets/");
+    rb_str_buf_cat2(str, bucket->bucket);
+    rb_str_buf_cat2(str, "/");
+    snprintf(buf, 150, "\" default_format=:%s, default_flags=0x%x, quiet=%s, connected=%s, timeout=%u>",
+            rb_id2name(SYM2ID(bucket->default_format)),
+            bucket->default_flags,
+            bucket->quiet ? "true" : "false",
+            bucket->handle ? "true" : "false",
+            bucket->timeout);
+    rb_str_buf_cat2(str, buf);
+
+    return str;
+}
+
+/*
+ * Delete the specified key
+ *
+ * @overload delete(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [Boolean] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *     Otherwise it will raise error in synchronous mode. In asynchronous
+ *     mode this option ignored.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to
+ *     update/delete an item simultaneously.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+ *   @raise [Couchbase::Error::NotFound] if key is missing in verbose mode
+ *
+ *   @example Delete the key in quiet mode (default)
+ *     c.set("foo", "bar")
+ *     c.delete("foo")        #=> true
+ *     c.delete("foo")        #=> false
+ *
+ *   @example Delete the key verbosely
+ *     c.set("foo", "bar")
+ *     c.delete("foo", :quiet => false)   #=> true
+ *     c.delete("foo", :quiet => false)   #=> will raise Couchbase::Error::NotFound
+ *
+ *   @example Delete the key with version check
+ *     ver = c.set("foo", "bar")          #=> 5992859822302167040
+ *     c.delete("foo", :cas => 123456)    #=> will raise Couchbase::Error::KeyExists
+ *     c.delete("foo", :cas => ver)       #=> true
+ */
     static VALUE
 cb_bucket_delete(int argc, VALUE *argv, VALUE self)
 {
@@ -1323,9 +1654,13 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     VALUE k, c, rv, proc, exc, opts;
     char *key;
     size_t nkey;
-    uint64_t cas = 0;
+    libcouchbase_cas_t cas = 0;
     libcouchbase_error_t err;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "11&", &k, &opts, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1357,6 +1692,8 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     ctx->rv = &rv;
     ctx->bucket = bucket;
     ctx->exception = Qnil;
+    seqno = bucket->seqno;
+    bucket->seqno++;
     err = libcouchbase_remove(bucket->handle, (const void *)ctx,
             (const void *)key, nkey, cas);
     exc = cb_check_error(err, "failed to schedule delete request", Qnil);
@@ -1364,11 +1701,13 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno++;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1388,9 +1727,13 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
     size_t nkey, nbytes;
     uint32_t flags;
     time_t exp = 0;
-    uint64_t cas = 0;
+    libcouchbase_cas_t cas = 0;
     libcouchbase_error_t err;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "21&", &k, &v, &opts, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1435,6 +1778,8 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
     ctx->proc = proc;
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
     ctx->exception = Qnil;
+    seqno = bucket->seqno;
+    bucket->seqno++;
     err = libcouchbase_store(bucket->handle, (const void *)ctx, cmd,
             (const void *)key, nkey, bytes, nbytes, flags, exp, cas);
     exc = cb_check_error(err, "failed to schedule set request", Qnil);
@@ -1442,11 +1787,13 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno++;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1471,7 +1818,11 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     uint64_t delta = 0, initial = 0;
     int create = 0;
     libcouchbase_error_t err;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "12&", &k, &d, &opts, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1514,6 +1865,8 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
     ctx->exception = Qnil;
     ctx->arithm = sign;
+    seqno = bucket->seqno;
+    bucket->seqno++;
     err = libcouchbase_arithmetic(bucket->handle, (const void *)ctx,
             (const void *)key, nkey, delta, exp, create, initial);
     exc = cb_check_error(err, "failed to schedule arithmetic request", k);
@@ -1521,11 +1874,13 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno++;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1535,29 +1890,282 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     }
 }
 
+/*
+ * Increment the value of an existing numeric key
+ *
+ * The increment methods enable you to increase a given stored integer
+ * value. These are the incremental equivalent of the decrement operations
+ * and work on the same basis; updating the value of a key if it can be
+ * parsed to an integer. The update operation occurs on the server and is
+ * provided at the protocol level. This simplifies what would otherwise be a
+ * two-stage get and set operation.
+ *
+ * @note that server values stored and transmitted as unsigned numbers,
+ *   therefore if you try to store negative number and then increment or
+ *   decrement it will cause overflow. (see "Integer overflow" example
+ *   below)
+ *
+ * @overload incr(key, delta = 1, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param delta [Fixnum] Integer (up to 64 bits) value to increment
+ *   @param options [Hash] Options for operation.
+ *   @option options [Boolean] :create (false) If set to +true+, it will
+ *     initialize the key with zero value and zero flags (use +:initial+
+ *     option to set another initial value). Note: it won't increment the
+ *     missing value.
+ *   @option options [Fixnum] :initial (0) Integer (up to 64 bits) value for
+ *     missing key initialization. This option imply +:create+ option is
+ *     +true+.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch). This option ignored for existent
+ *     keys.
+ *   @option options [Boolean] :extended (false) If set to +true+, the
+ *     operation will return tuple +[value, cas]+, otherwise (by default) it
+ *     returns just value.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+, +value+, +cas+).
+ *
+ *   @return [Fixnum] the actual value of the key.
+ *
+ *   @raise [Couchbase::Error::NotFound] if key is missing and +:create+
+ *     option isn't +true+.
+ *
+ *   @raise [Couchbase::Error::DeltaBadval] if the key contains non-numeric
+ *     value
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Increment key by one
+ *     c.incr("foo")
+ *
+ *   @example Increment key by 50
+ *     c.incr("foo", 50)
+ *
+ *   @example Increment key by one <b>OR</b> initialize with zero
+ *     c.incr("foo", :create => true)   #=> will return old+1 or 0
+ *
+ *   @example Increment key by one <b>OR</b> initialize with three
+ *     c.incr("foo", 50, :initial => 3) #=> will return old+50 or 3
+ *
+ *   @example Increment key and get its CAS value
+ *     val, cas = c.incr("foo", :extended => true)
+ *
+ *   @example Integer overflow
+ *     c.set("foo", -100)
+ *     c.get("foo")           #=> -100
+ *     c.incr("foo")          #=> 18446744073709551517
+ *
+ *   @example Asynchronous invocation
+ *     c.run do
+ *       c.incr("foo") do |ret|
+ *         ret.operation   #=> :increment
+ *         ret.success?    #=> true
+ *         ret.key         #=> "foo"
+ *         ret.value
+ *         ret.cas
+ *       end
+ *     end
+ *
+ */
 static VALUE
 cb_bucket_incr(int argc, VALUE *argv, VALUE self)
 {
     return cb_bucket_arithmetic(+1, argc, argv, self);
 }
 
+/*
+ * Decrement the value of an existing numeric key
+ *
+ * The decrement methods reduce the value of a given key if the
+ * corresponding value can be parsed to an integer value. These operations
+ * are provided at a protocol level to eliminate the need to get, update,
+ * and reset a simple integer value in the database. It supports the use of
+ * an explicit offset value that will be used to reduce the stored value in
+ * the database.
+ *
+ * @note that server values stored and transmitted as unsigned numbers,
+ *   therefore if you try to decrement negative or zero key, you will always
+ *   get zero.
+ *
+ * @overload decr(key, delta = 1, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param delta [Fixnum] Integer (up to 64 bits) value to decrement
+ *   @param options [Hash] Options for operation.
+ *   @option options [Boolean] :create (false) If set to +true+, it will
+ *     initialize the key with zero value and zero flags (use +:initial+
+ *     option to set another initial value). Note: it won't decrement the
+ *     missing value.
+ *   @option options [Fixnum] :initial (0) Integer (up to 64 bits) value for
+ *     missing key initialization. This option imply +:create+ option is
+ *     +true+.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch). This option ignored for existent
+ *     keys.
+ *   @option options [Boolean] :extended (false) If set to +true+, the
+ *     operation will return tuple +[value, cas]+, otherwise (by default) it
+ *     returns just value.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+, +value+, +cas+).
+ *
+ *   @return [Fixnum] the actual value of the key.
+ *
+ *   @raise [Couchbase::Error::NotFound] if key is missing and +:create+
+ *     option isn't +true+.
+ *
+ *   @raise [Couchbase::Error::DeltaBadval] if the key contains non-numeric
+ *     value
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Decrement key by one
+ *     c.decr("foo")
+ *
+ *   @example Decrement key by 50
+ *     c.decr("foo", 50)
+ *
+ *   @example Decrement key by one <b>OR</b> initialize with zero
+ *     c.decr("foo", :create => true)   #=> will return old-1 or 0
+ *
+ *   @example Decrement key by one <b>OR</b> initialize with three
+ *     c.decr("foo", 50, :initial => 3) #=> will return old-50 or 3
+ *
+ *   @example Decrement key and get its CAS value
+ *     val, cas = c.decr("foo", :extended => true)
+ *
+ *   @example Decrementing zero
+ *     c.set("foo", 0)
+ *     c.decrement("foo", 100500)   #=> 0
+ *
+ *   @example Decrementing negative value
+ *     c.set("foo", -100)
+ *     c.decrement("foo", 100500)   #=> 0
+ *
+ *   @example Asynchronous invocation
+ *     c.run do
+ *       c.decr("foo") do |ret|
+ *         ret.operation   #=> :decrement
+ *         ret.success?    #=> true
+ *         ret.key         #=> "foo"
+ *         ret.value
+ *         ret.cas
+ *       end
+ *     end
+ *
+ */
 static VALUE
 cb_bucket_decr(int argc, VALUE *argv, VALUE self)
 {
     return cb_bucket_arithmetic(-1, argc, argv, self);
 }
 
+/*
+ * Obtain an object stored in Couchbase by given key.
+ *
+ * @overload get(*keys, options = {})
+ *   @param keys [String, Symbol, Array] One or several keys to fetch
+ *   @param options [Hash] Options for operation.
+ *   @option options [Boolean] :extended (false) If set to +true+, the
+ *     operation will return tuple +[value, flags, cas]+, otherwise (by
+ *     default) it returns just value.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *   @option options [Boolean] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *     Otherwise it will raise error in synchronous mode. In asynchronous
+ *     mode this option ignored.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+, +value+, +flags+,
+ *     +cas+).
+ *
+ *   @return [Object, Array, Hash] the value(s) (or tuples in extended mode)
+ *     assiciated with the key.
+ *
+ *   @raise [Couchbase::Error::NotFound] if the key is missing in the
+ *     bucket.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Get single value in quite mode (the default)
+ *     c.get("foo")     #=> the associated value or nil
+ *
+ *   @example Use alternative hash-like syntax
+ *     c["foo"]         #=> the associated value or nil
+ *
+ *   @example Get single value in verbose mode
+ *     c.get("missing-foo", :quiet => false)  #=> raises Couchbase::NotFound
+ *
+ *   @example Get and touch single value. The key won't be accessible after 10 seconds
+ *     c.get("foo", :ttl => 10)
+ *
+ *   @example Extended get
+ *     val, flags, cas = c.get("foo", :extended => true)
+ *
+ *   @example Get multiple keys
+ *     c.get("foo", "bar", "baz")   #=> [val1, val2, val3]
+ *
+ *   @example Extended get multiple keys
+ *     c.get("foo", "bar", :extended => true)
+ *     #=> {"foo" => [val1, flags1, cas1], "bar" => [val2, flags2, cas2]}
+ *
+ *   @example Asynchronous get
+ *     c.run do
+ *       c.get("foo", "bar", "baz") do |res|
+ *         ret.operation   #=> :get
+ *         ret.success?    #=> true
+ *         ret.key         #=> "foo", "bar" or "baz" in separate calls
+ *         ret.value
+ *         ret.flags
+ *         ret.cas
+ *       end
+ *     end
+ *
+ * @overload get(keys, options = {})
+ *   When the method receive hash map, it will behave like it receive list
+ *   of keys (+keys.keys+), but also touch each key setting expiry time to
+ *   the corresponding value. But unlike usual get this command always
+ *   return hash map +{key => value}+ or +{key => [value, flags, cas]}+.
+ *
+ *   @param keys [Hash] Map key-ttl
+ *   @param options [Hash] Options for operation. (see options definition
+ *     above)
+ *
+ *   @return [Hash] the values (or tuples in extended mode) assiciated with
+ *     the keys.
+ *
+ *   @example Get and touch multiple keys
+ *     c.get("foo" => 10, "bar" => 20)   #=> {"foo" => val1, "bar" => val2}
+ *
+ *   @example Extended get and touch multiple keys
+ *     c.get({"foo" => 10, "bar" => 20}, :extended => true)
+ *     #=> {"foo" => [val1, flags1, cas1], "bar" => [val2, flags2, cas2]}
+ */
     static VALUE
 cb_bucket_get(int argc, VALUE *argv, VALUE self)
 {
     bucket_t *bucket = DATA_PTR(self);
     context_t *ctx;
-    VALUE args, rv, proc, exc, vv = Qnil, keys;
+    VALUE args, rv, proc, exc, keys;
     long nn;
     libcouchbase_error_t err;
     struct key_traits *traits;
-    int extended;
+    int extended, mgat;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1569,6 +2177,7 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
+    mgat = traits->mgat;
     keys = traits->keys_ary;
     ctx->proc = proc;
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
@@ -1578,9 +2187,8 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     rv = rb_hash_new();
     ctx->rv = &rv;
     ctx->exception = Qnil;
-    if (!bucket->async) {
-        bucket->seqno = 0;
-    }
+    seqno = bucket->seqno;
+    bucket->seqno += nn;
     err = libcouchbase_mget(bucket->handle, (const void *)ctx,
             traits->nkeys, (const void * const *)traits->keys,
             traits->lens, (traits->explicit_ttl) ? traits->ttls : NULL);
@@ -1593,11 +2201,13 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno += nn;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         extended = ctx->extended;
         free(ctx);
@@ -1607,27 +2217,88 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
         if (bucket->exception != Qnil) {
             rb_exc_raise(bucket->exception);
         }
+        if (mgat || (extended && nn > 1)) {
+            return rv;  /* return as a hash {key => [value, flags, cas], ...} */
+        }
         if (nn > 1) {
-            if (extended) {
-                return rv;  /* return as a hash {key => [value, flags, cas], ...} */
-            } else {
-                long ii;
-                VALUE *keys_ptr, ret;
-                ret = rb_ary_new();
-                keys_ptr = RARRAY_PTR(keys);
-                for (ii = 0; ii < nn; ii++) {
-                    rb_ary_push(ret, rb_hash_aref(rv, keys_ptr[ii]));
-                }
-                return ret;  /* return as an array [value1, value2, ...] */
+            long ii;
+            VALUE *keys_ptr, ret;
+            ret = rb_ary_new();
+            keys_ptr = RARRAY_PTR(keys);
+            for (ii = 0; ii < nn; ii++) {
+                rb_ary_push(ret, rb_hash_aref(rv, keys_ptr[ii]));
             }
+            return ret;  /* return as an array [value1, value2, ...] */
         } else {
+            VALUE vv = Qnil;
             rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
             return vv;
         }
     }
 }
 
-    static VALUE
+/*
+ * Update the expiry time of an item
+ *
+ * The +touch+ method allow you to update the expiration time on a given
+ * key. This can be useful for situations where you want to prevent an item
+ * from expiring without resetting the associated value. For example, for a
+ * session database you might want to keep the session alive in the database
+ * each time the user accesses a web page without explicitly updating the
+ * session value, keeping the user's session active and available.
+ *
+ * @overload touch(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Boolean] +true+ if the operation was successful and +false+
+ *     otherwise.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Touch value using +default_ttl+
+ *     c.touch("foo")
+ *
+ *   @example Touch value using custom TTL (10 seconds)
+ *     c.touch("foo", :ttl => 10)
+ *
+ * @overload touch(keys)
+ *   @param keys [Hash] The Hash where keys represent the keys in the
+ *     database, values -- the expiry times for corresponding key. See
+ *     description of +:ttl+ argument above for more information about TTL
+ *     values.
+ *
+ *   @yieldparam ret [Result] the result of operation for each key in
+ *     asynchronous mode (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Hash] Mapping keys to result of touch operation (+true+ if the
+ *     operation was successful and +false+ otherwise)
+ *
+ *   @example Touch several values
+ *     c.touch("foo" => 10, :bar => 20) #=> {"foo" => true, "bar" => true}
+ *
+ *   @example Touch several values in async mode
+ *     c.run do
+ *       c.touch("foo" => 10, :bar => 20) do |ret|
+ *          ret.operation   #=> :touch
+ *          ret.success?    #=> true
+ *          ret.key         #=> "foo" and "bar" in separate calls
+ *       end
+ *     end
+ *
+ *   @example Touch single value
+ *     c.touch("foo" => 10)             #=> true
+ *
+ */
+   static VALUE
 cb_bucket_touch(int argc, VALUE *argv, VALUE self)
 {
     bucket_t *bucket = DATA_PTR(self);
@@ -1636,7 +2307,11 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     size_t nn;
     libcouchbase_error_t err;
     struct key_traits *traits;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1651,26 +2326,29 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     ctx->proc = proc;
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
     ctx->bucket = bucket;
-    rv = rb_ary_new();
+    rv = rb_hash_new();
     ctx->rv = &rv;
     ctx->exception = Qnil;
-    if (!bucket->async) {
-        bucket->seqno = 0;
-    }
+    seqno = bucket->seqno;
+    bucket->seqno += nn;
     err = libcouchbase_mtouch(bucket->handle, (const void *)ctx,
             traits->nkeys, (const void * const *)traits->keys,
             traits->lens, traits->ttls);
+    free(traits->keys);
+    free(traits->lens);
     free(traits);
     exc = cb_check_error(err, "failed to schedule touch request", Qnil);
     if (exc != Qnil) {
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno += nn;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1680,13 +2358,39 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
             rb_exc_raise(bucket->exception);
         }
         if (nn > 1) {
-            return rv;
+            return rv;  /* return as a hash {key => true, ...} */
         } else {
-            return rb_ary_pop(rv);
+            VALUE vv = Qnil;
+            rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
+            return vv;
         }
     }
 }
 
+/*
+ * Deletes all values from a server
+ *
+ * @overload flush
+ *   @yieldparam [Result] ret the object with +error+, +node+ and +operation+
+ *     attributes.
+ *
+ *   @return [Boolean] +true+ on success
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Simple flush the bucket
+ *     c.flush    #=> true
+ *
+ *   @example Asynchronous flush
+ *     c.run do
+ *       c.flush do |ret|
+ *         ret.operation   #=> :flush
+ *         ret.success?    #=> true
+ *         ret.node        #=> "localhost:11211"
+ *       end
+ *     end
+ */
     static VALUE
 cb_bucket_flush(VALUE self)
 {
@@ -1694,7 +2398,11 @@ cb_bucket_flush(VALUE self)
     context_t *ctx;
     VALUE rv, exc;
     libcouchbase_error_t err;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     if (!bucket->async && rb_block_given_p()) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
@@ -1712,17 +2420,99 @@ cb_bucket_flush(VALUE self)
         ctx->proc = Qnil;
     }
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    seqno = bucket->seqno;
+    bucket->seqno++;
     err = libcouchbase_flush(bucket->handle, (const void *)ctx);
     exc = cb_check_error(err, "failed to schedule flush request", Qnil);
     if (exc != Qnil) {
         free(ctx);
         rb_exc_raise(exc);
     }
+    if (bucket->async) {
+        return Qnil;
+    } else {
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
+        exc = ctx->exception;
+        free(ctx);
+        if (exc != Qnil) {
+            rb_exc_raise(exc);
+        }
+        return rv;
+    }
+}
+
+/*
+ * Returns versions of the server for each node in the cluster
+ *
+ * @overload version
+ *   @yieldparam [Result] ret the object with +error+, +node+, +operation+
+ *     and +value+ attributes.
+ *
+ *   @return [Hash] node-version pairs
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Synchronous version request
+ *     c.version            #=> will render version
+ *
+ *   @example Asynchronous version request
+ *     c.run do
+ *       c.version do |ret|
+ *         ret.operation    #=> :version
+ *         ret.success?     #=> true
+ *         ret.node         #=> "localhost:11211"
+ *         ret.value        #=> will render version
+ *       end
+ *     end
+ */
+    static VALUE
+cb_bucket_version(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+    context_t *ctx;
+    VALUE rv, exc;
+    libcouchbase_error_t err;
+    long seqno;
+
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
+    if (!bucket->async && rb_block_given_p()) {
+        rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
+    }
+    ctx = calloc(1, sizeof(context_t));
+    if (ctx == NULL) {
+        rb_raise(eNoMemoryError, "failed to allocate memory for context");
+    }
+    rv = rb_hash_new();
+    ctx->rv = &rv;
+    ctx->bucket = bucket;
+    ctx->exception = Qnil;
+    if (rb_block_given_p()) {
+        ctx->proc = rb_block_proc();
+    } else {
+        ctx->proc = Qnil;
+    }
+    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    seqno = bucket->seqno;
     bucket->seqno++;
+    err = libcouchbase_server_versions(bucket->handle, (const void *)ctx);
+    exc = cb_check_error(err, "failed to schedule version request", Qnil);
+    if (exc != Qnil) {
+        free(ctx);
+        rb_exc_raise(exc);
+    }
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1732,6 +2522,46 @@ cb_bucket_flush(VALUE self)
     }
 }
 
+/*
+ * Request server statistics.
+ *
+ * Fetches stats from each node in cluster. Without a key specified the
+ * server will respond with a "default" set of statistical information. In
+ * asynchronous mode each statistic is returned in separate call where the
+ * Result object yielded (+#key+ contains the name of the statistical item
+ * and the +#value+ contains the value, the +#node+ will indicate the server
+ * address). In synchronous mode it returns the hash of stats keys and
+ * node-value pairs as a value.
+ *
+ * @overload stats(arg = nil)
+ *   @param [String] arg argument to STATS query
+ *   @yieldparam [Result] ret the object with +node+, +key+ and +value+
+ *     attributes.
+ *
+ *   @example Found how many items in the bucket
+ *     total = 0
+ *     c.stats["total_items"].each do |key, value|
+ *       total += value.to_i
+ *     end
+ *
+ *   @example Found total items number asynchronously
+ *     total = 0
+ *     c.run do
+ *       c.stats do |ret|
+ *         if ret.key == "total_items"
+ *           total += ret.value.to_i
+ *         end
+ *       end
+ *     end
+ *
+ *   @example Get memory stats (works on couchbase buckets)
+ *     c.stats(:memory)   #=> {"mem_used"=>{...}, ...}
+ *
+ *   @return [Hash] where keys are stat keys, values are host-value pairs
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ */
     static VALUE
 cb_bucket_stats(int argc, VALUE *argv, VALUE self)
 {
@@ -1741,7 +2571,11 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
     char *key;
     size_t nkey;
     libcouchbase_error_t err;
+    long seqno;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
     rb_scan_args(argc, argv, "01&", &arg, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
@@ -1758,12 +2592,15 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
     rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
     ctx->exception = Qnil;
     if (arg != Qnil) {
+        arg = unify_key(arg);
         key = RSTRING_PTR(arg);
         nkey = RSTRING_LEN(arg);
     } else {
         key = NULL;
         nkey = 0;
     }
+    seqno = bucket->seqno;
+    bucket->seqno++;
     err = libcouchbase_server_stats(bucket->handle, (const void *)ctx,
             key, nkey);
     exc = cb_check_error(err, "failed to schedule stat request", Qnil);
@@ -1771,11 +2608,13 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
         free(ctx);
         rb_exc_raise(exc);
     }
-    bucket->seqno++;
     if (bucket->async) {
         return Qnil;
     } else {
-        bucket->io->run_event_loop(bucket->io);
+        if (bucket->seqno - seqno > 0) {
+            /* we have some operations pending */
+            bucket->io->run_event_loop(bucket->io);
+        }
         exc = ctx->exception;
         free(ctx);
         if (exc != Qnil) {
@@ -1795,12 +2634,31 @@ do_run(VALUE *args)
 {
     VALUE self = args[0], proc = args[1], exc;
     bucket_t *bucket = DATA_PTR(self);
+    time_t tm;
+    uint32_t old_tmo, new_tmo, diff;
 
+    if (bucket->handle == NULL) {
+        rb_raise(eConnectError, "closed connection");
+    }
+    if (bucket->async) {
+        rb_raise(eInvalidError, "nested #run");
+    }
     bucket->seqno = 0;
     bucket->async = 1;
+
+    tm = time(NULL);
     cb_proc_call(proc, 1, self);
     if (bucket->seqno > 0) {
+        old_tmo = libcouchbase_get_timeout(bucket->handle);
+        diff = (uint32_t)(time(NULL) - tm + 1);
+        diff *= 1000000;
+        new_tmo = bucket->timeout += diff;
+        libcouchbase_set_timeout(bucket->handle, bucket->timeout);
         bucket->io->run_event_loop(bucket->io);
+        /* restore timeout if it wasn't changed */
+        if (bucket->timeout == new_tmo) {
+            libcouchbase_set_timeout(bucket->handle, old_tmo);
+        }
         if (bucket->exception != Qnil) {
             exc = bucket->exception;
             bucket->exception = Qnil;
@@ -1823,7 +2681,7 @@ ensure_run(VALUE *args)
 /*
  * Run the event loop.
  *
- * @yieldparam [Bucket] the bucket instance
+ * @yieldparam [Bucket] bucket the bucket instance
  *
  * @example Use block to run the loop
  *   c = Couchbase.new
@@ -1838,6 +2696,9 @@ ensure_run(VALUE *args)
  *   end
  *   c.run(&operations)
  *
+ * @return [nil]
+ *
+ * @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
  */
     static VALUE
 cb_bucket_run(VALUE self)
@@ -1852,7 +2713,72 @@ cb_bucket_run(VALUE self)
 }
 
 /*
- * Unconditionally set the object in the cache
+ * Unconditionally store the object in the Couchbase
+ *
+ * @overload set(key, value, options = {})
+ *
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param value [Object] Value to be stored
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *   @option options [Fixnum] :flags (self.default_flags) Flags for storage
+ *     options. Flags are ignored by the server but preserved for use by the
+ *     client. For more info see {Bucket#default_flags}.
+ *   @option options [Symbol] :format (self.default_format) The
+ *     representation for storing the value in the bucket. For more info see
+ *     {Bucket#default_format}.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to update an
+ *     item simultaneously.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Fixnum] The CAS value of the object.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect}).
+ *   @raise [Couchbase::Error::KeyExists] if the key already exists on the
+ *     server.
+ *   @raise [Couchbase::Error::ValueFormat] if the value cannot be serialized
+ *     with chosen encoder, e.g. if you try to store the Hash in +:plain+
+ *     mode.
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Store the key which will be expired in 2 seconds using relative TTL.
+ *     c.set("foo", "bar", :ttl => 2)
+ *
+ *   @example Store the key which will be expired in 2 seconds using absolute TTL.
+ *     c.set("foo", "bar", :ttl => Time.now.to_i + 2)
+ *
+ *   @example Force JSON document format for value
+ *     c.set("foo", {"bar" => "baz}, :format => :document)
+ *
+ *   @example Use hash-like syntax to store the value
+ *     c.set["foo"] = {"bar" => "baz}
+ *
+ *   @example Use extended hash-like syntax
+ *     c["foo", {:flags => 0x1000, :format => :plain}] = "bar"
+ *     c["foo", :flags => 0x1000] = "bar"  # for ruby 1.9.x only
+ *
+ *   @example Set application specific flags (note that it will be OR-ed with format flags)
+ *     c.set("foo", "bar", :flags => 0x1000)
+ *
+ *   @example Perform optimistic locking by specifying last known CAS version
+ *     c.set("foo", "bar", :cas => 8835713818674332672)
+ *
+ *   @example Perform asynchronous call
+ *     c.run do
+ *       c.set("foo", "bar") do |ret|
+ *         ret.operation   #=> :set
+ *         ret.success?    #=> true
+ *         ret.key         #=> "foo"
+ *         ret.cas
+ *       end
+ *     end
  */
     static VALUE
 cb_bucket_set(int argc, VALUE *argv, VALUE self)
@@ -1861,7 +2787,43 @@ cb_bucket_set(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * Add the item to the cache, but fail if the object exists alread
+ * Add the item to the database, but fail if the object exists already
+ *
+ * @overload add(key, value, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param value [Object] Value to be stored
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *   @option options [Fixnum] :flags (self.default_flags) Flags for storage
+ *     options. Flags are ignored by the server but preserved for use by the
+ *     client. For more info see {Bucket#default_flags}.
+ *   @option options [Symbol] :format (self.default_format) The
+ *     representation for storing the value in the bucket. For more info see
+ *     {Bucket#default_format}.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to update an
+ *     item simultaneously.
+ *
+ *   @yieldparam ret [Result] the result of operation in asynchronous mode
+ *     (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Fixnum] The CAS value of the object.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [Couchbase::Error::KeyExists] if the key already exists on the
+ *     server
+ *   @raise [Couchbase::Error::ValueFormat] if the value cannot be serialized
+ *     with chosen encoder, e.g. if you try to store the Hash in +:plain+
+ *     mode.
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Add the same key twice
+ *     c.add("foo", "bar")  #=> stored successully
+ *     c.add("foo", "baz")  #=> will raise Couchbase::Error::KeyExists: failed to store value (key="foo", error=0x0c)
  */
     static VALUE
 cb_bucket_add(int argc, VALUE *argv, VALUE self)
@@ -1870,7 +2832,31 @@ cb_bucket_add(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * Replace the existing object in the cache
+ * Replace the existing object in the database
+ *
+ * @overload replace(key, value, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param value [Object] Value to be stored
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
+ *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
+ *     absolute times (from the epoch).
+ *   @option options [Fixnum] :flags (self.default_flags) Flags for storage
+ *     options. Flags are ignored by the server but preserved for use by the
+ *     client. For more info see {Bucket#default_flags}.
+ *   @option options [Symbol] :format (self.default_format) The
+ *     representation for storing the value in the bucket. For more info see
+ *     {Bucket#default_format}.
+ *
+ *   @return [Fixnum] The CAS value of the object.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [Couchbase::Error::NotFound] if the key doesn't exists
+ *   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Replacing missing key
+ *     c.replace("foo", "baz")  #=> will raise Couchbase::Error::NotFound: failed to store value (key="foo", error=0x0d)
  */
     static VALUE
 cb_bucket_replace(int argc, VALUE *argv, VALUE self)
@@ -1880,6 +2866,67 @@ cb_bucket_replace(int argc, VALUE *argv, VALUE self)
 
 /*
  * Append this object to the existing object
+ *
+ * @note This operation is kind of data-aware from server point of view.
+ *   This mean that the server treats value as binary stream and just
+ *   perform concatenation, therefore it won't work with +:marshal+ and
+ *   +:document+ formats, because of lack of knowledge how to merge values
+ *   in these formats. See Bucket#cas for workaround.
+ *
+ * @overload append(key, value, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param value [Object] Value to be stored
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to update an
+ *     item simultaneously.
+ *   @option options [Symbol] :format (self.default_format) The
+ *     representation for storing the value in the bucket. For more info see
+ *     {Bucket#default_format}.
+ *
+ *   @return [Fixnum] The CAS value of the object.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+ *   @raise [Couchbase::Error::NotStored] if the key doesn't exist
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Simple append
+ *     c.set("foo", "aaa")
+ *     c.append("foo", "bbb")
+ *     c.get("foo")           #=> "aaabbb"
+ *
+ *   @example Implementing sets using append
+ *     def set_add(key, *values)
+ *       encoded = values.flatten.map{|v| "+#{v} "}.join
+ *       append(key, encoded)
+ *     end
+ *
+ *     def set_remove(key, *values)
+ *       encoded = values.flatten.map{|v| "-#{v} "}.join
+ *       append(key, encoded)
+ *     end
+ *
+ *     def set_get(key)
+ *       encoded = get(key)
+ *       ret = Set.new
+ *       encoded.split(' ').each do |v|
+ *         op, val = v[0], v[1..-1]
+ *         case op
+ *         when "-"
+ *           ret.delete(val)
+ *         when "+"
+ *           ret.add(val)
+ *         end
+ *       end
+ *       ret
+ *     end
+ *
+ *   @example Using optimistic locking. The operation will fail on CAS mismatch
+ *     ver = c.set("foo", "aaa")
+ *     c.append("foo", "bbb", :cas => ver)
  */
     static VALUE
 cb_bucket_append(int argc, VALUE *argv, VALUE self)
@@ -1889,6 +2936,46 @@ cb_bucket_append(int argc, VALUE *argv, VALUE self)
 
 /*
  * Prepend this object to the existing object
+ *
+ * @note This operation is kind of data-aware from server point of view.
+ *   This mean that the server treats value as binary stream and just
+ *   perform concatenation, therefore it won't work with +:marshal+ and
+ *   +:document+ formats, because of lack of knowledge how to merge values
+ *   in these formats. See Bucket#cas for workaround.
+ *
+ * @overload prepend(key, value, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param value [Object] Value to be stored
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *     created on the server and is guaranteed to be unique for each value of
+ *     a given key. This value is used to provide simple optimistic
+ *     concurrency control when multiple clients or threads try to update an
+ *     item simultaneously.
+ *   @option options [Symbol] :format (self.default_format) The
+ *     representation for storing the value in the bucket. For more info see
+ *     {Bucket#default_format}.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+ *   @raise [Couchbase::Error::NotStored] if the key doesn't exist
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @example Simple prepend example
+ *     c.set("foo", "aaa")
+ *     c.prepend("foo", "bbb")
+ *     c.get("foo")           #=> "bbbaaa"
+ *
+ *   @example Using explicit format option
+ *     c.default_format       #=> :document
+ *     c.set("foo", {"y" => "z"})
+ *     c.prepend("foo", '[', :format => :plain)
+ *     c.append("foo", ', {"z": "y"}]', :format => :plain)
+ *     c.get("foo")           #=> [{"y"=>"z"}, {"z"=>"y"}]
+ *
+ *   @example Using optimistic locking. The operation will fail on CAS mismatch
+ *     ver = c.set("foo", "aaa")
+ *     c.prepend("foo", "bbb", :cas => ver)
  */
     static VALUE
 cb_bucket_prepend(int argc, VALUE *argv, VALUE self)
@@ -1910,6 +2997,28 @@ cb_bucket_aset(int argc, VALUE *argv, VALUE self)
     return cb_bucket_set(argc, argv, self);
 }
 
+/*
+ * Close the connection to the cluster
+ *
+ * @return [true]
+ *
+ * @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ */
+    static VALUE
+cb_bucket_disconnect(VALUE self)
+{
+    bucket_t *bucket = DATA_PTR(self);
+
+    if (bucket->handle) {
+        libcouchbase_destroy(bucket->handle);
+        bucket->handle = NULL;
+        bucket->io = NULL;
+        return Qtrue;
+    } else {
+        rb_raise(eConnectError, "closed connection");
+    }
+}
+
 /*
  * Check if result of operation was successful.
  *
@@ -1922,10 +3031,15 @@ cb_result_success_p(VALUE self)
     return RTEST(rb_ivar_get(self, id_iv_error)) ? Qfalse : Qtrue;
 }
 
+/*
+ * Returns a string containing a human-readable representation of the Result.
+ *
+ * @return [String]
+ */
     static VALUE
 cb_result_inspect(VALUE self)
 {
-    VALUE str, attr, errno;
+    VALUE str, attr, error;
     char buf[100];
 
     str = rb_str_buf_new2("#<");
@@ -1935,12 +3049,12 @@ cb_result_inspect(VALUE self)
 
     attr = rb_ivar_get(self, id_iv_error);
     if (RTEST(attr)) {
-        errno = rb_ivar_get(attr, id_iv_error);
+        error = rb_ivar_get(attr, id_iv_error);
     } else {
-        errno = INT2FIX(0);
+        error = INT2FIX(0);
     }
     rb_str_buf_cat2(str, " error=0x");
-    rb_str_append(str, rb_funcall(errno, id_to_s, 1, INT2FIX(16)));
+    rb_str_append(str, rb_funcall(error, id_to_s, 1, INT2FIX(16)));
 
     attr = rb_ivar_get(self, id_iv_key);
     if (RTEST(attr)) {
@@ -1975,6 +3089,7 @@ cb_result_inspect(VALUE self)
 Init_couchbase_ext(void)
 {
     mJSON = rb_const_get(rb_cObject, rb_intern("JSON"));
+    mURI = rb_const_get(rb_cObject, rb_intern("URI"));
     mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
     mCouchbase = rb_define_module("Couchbase");
 
@@ -1985,6 +3100,9 @@ Init_couchbase_ext(void)
     /* Document-class: Couchbase::Error::Auth
      * Authentication error */
     eAuthError = rb_define_class_under(mError, "Auth", eBaseError);
+    /* Document-class: Couchbase::Error::BucketNotFound
+     * The given bucket not found in the cluster */
+    eBucketNotFoundError = rb_define_class_under(mError, "BucketNotFound", eBaseError);
     /* Document-class: Couchbase::Error::Busy
      * The cluster is too busy now. Try again later */
     eBusyError = rb_define_class_under(mError, "Busy", eBaseError);
@@ -2045,6 +3163,12 @@ Init_couchbase_ext(void)
     /* Document-class: Couchbase::Error::Protocol
      * Protocol error */
     eProtocolError = rb_define_class_under(mError, "Protocol", eBaseError);
+    /* Document-class: Couchbase::Error::Timeout
+     * Timeout error */
+    eTimeoutError = rb_define_class_under(mError, "Timeout", eBaseError);
+    /* Document-class: Couchbase::Error::Connect
+     * Connect error */
+    eConnectError = rb_define_class_under(mError, "Connect", eBaseError);
 
     /* Document-method: error
      * @return [Boolean] the error code from libcouchbase */
@@ -2064,7 +3188,7 @@ Init_couchbase_ext(void)
     id_iv_operation = rb_intern("@operation");
 
     /* Document-class: Couchbase::Result
-     * Protocol error */
+     * The object which yielded to asynchronous callbacks */
     cResult = rb_define_class_under(mCouchbase, "Result", rb_cObject);
     rb_define_method(cResult, "inspect", cb_result_inspect, 0);
     rb_define_method(cResult, "success?", cb_result_success_p, 0);
@@ -2072,7 +3196,7 @@ Init_couchbase_ext(void)
      * @return [Symbol] */
     rb_define_attr(cResult, "operation", 1, 0);
     /* Document-method: error
-     * @return [Error::Base] */
+     * @return [Couchbase::Error::Base] */
     rb_define_attr(cResult, "error", 1, 0);
     /* Document-method: key
      * @return [String] */
@@ -2100,17 +3224,35 @@ Init_couchbase_ext(void)
      * Couchbase. */
     cBucket = rb_define_class_under(mCouchbase, "Bucket", rb_cObject);
     object_space = rb_hash_new();
+    /* @private Hack to avoid GC in some cases */
     rb_define_const(cBucket, "OBJECT_SPACE", object_space);
 
+    /* 0x03: Bitmask for flag bits responsible for format */
     rb_define_const(cBucket, "FMT_MASK", INT2FIX(FMT_MASK));
+    /* 0x00: Document format. The (default) format supports most of ruby
+     * types which could be mapped to JSON data (hashes, arrays, strings,
+     * numbers). Future version will be able to run map/reduce queries on
+     * the values in the document form (hashes). */
     rb_define_const(cBucket, "FMT_DOCUMENT", INT2FIX(FMT_DOCUMENT));
+    /* 0x01:  Marshal format. The format which supports transparent
+     * serialization of ruby objects with standard <tt>Marshal.dump</tt> and
+     * <tt>Marhal.load</tt> methods. */
     rb_define_const(cBucket, "FMT_MARSHAL", INT2FIX(FMT_MARSHAL));
+    /* 0x02:  Plain format. The format which force client don't apply any
+     * conversions to the value, but it should be passed as String. It
+     * could be useful for building custom algorithms or formats. For
+     * example implement set:
+     * http://dustin.github.com/2011/02/17/memcached-set.html */
     rb_define_const(cBucket, "FMT_PLAIN", INT2FIX(FMT_PLAIN));
 
     rb_define_singleton_method(cBucket, "new", cb_bucket_new, -1);
 
     rb_define_method(cBucket, "initialize", cb_bucket_init, -1);
     rb_define_method(cBucket, "inspect", cb_bucket_inspect, 0);
+
+    /* Document-method: seqno
+     * The number of scheduled commands */
+    /* rb_define_attr(cBucket, "seqno", 1, 0); */
     rb_define_method(cBucket, "seqno", cb_bucket_seqno, 0);
 
     rb_define_method(cBucket, "add", cb_bucket_add, -1);
@@ -2124,39 +3266,27 @@ Init_couchbase_ext(void)
     rb_define_method(cBucket, "delete", cb_bucket_delete, -1);
     rb_define_method(cBucket, "stats", cb_bucket_stats, -1);
     rb_define_method(cBucket, "flush", cb_bucket_flush, 0);
+    rb_define_method(cBucket, "version", cb_bucket_version, 0);
     rb_define_method(cBucket, "incr", cb_bucket_incr, -1);
     rb_define_method(cBucket, "decr", cb_bucket_decr, -1);
+    rb_define_method(cBucket, "disconnect", cb_bucket_disconnect, 0);
+    rb_define_method(cBucket, "reconnect", cb_bucket_reconnect, -1);
 
     rb_define_alias(cBucket, "decrement", "decr");
     rb_define_alias(cBucket, "increment", "incr");
 
     rb_define_alias(cBucket, "[]", "get");
-    /* rb_define_alias(cBucket, "[]=", "set"); */
+    rb_define_alias(cBucket, "[]=", "set");
     rb_define_method(cBucket, "[]=", cb_bucket_aset, -1);
 
-    /* Document-method: async?
-     * Flag specifying if the connection asynchronous.
-     *
-     * By default all operations are synchronous and block waiting for
-     * results, but you can make them asynchronous and run event loop
-     * explicitly. (see Bucket#run)
-     *
-     * @example Return value of #get operation depending on async flag
-     *   connection = Connection.new
-     *   connection.async?      #=> false
-     *
-     *   connection.run do |conn|
-     *     conn.async?          #=> true
-     *   end
-     *
-     * @return [Boolean] */
+    rb_define_method(cBucket, "connected?", cb_bucket_connected_p, 0);
     rb_define_method(cBucket, "async?", cb_bucket_async_p, 0);
 
     /* Document-method: quiet
      * Flag specifying behaviour for operations on missing keys
      *
      * If it is +true+, the operations will silently return +nil+ or +false+
-     * instead of raising Couchbase::Error::NotFoundError.
+     * instead of raising {Couchbase::Error::NotFound}.
      *
      * @example Hiding cache miss (considering "miss" key is not stored)
      *   connection.quiet = true
@@ -2164,13 +3294,13 @@ Init_couchbase_ext(void)
      *
      * @example Raising errors on miss (considering "miss" key is not stored)
      *   connection.quiet = false
-     *   connection.get("miss")     #=> will raise Couchbase::Error::NotFoundError
+     *   connection.get("miss")     #=> will raise Couchbase::Error::NotFound
      *
      * @return [Boolean] */
-    rb_define_attr(cBucket, "quiet", 1, 1);
+    /* rb_define_attr(cBucket, "quiet", 1, 1); */
+    rb_define_method(cBucket, "quiet", cb_bucket_quiet_get, 0);
     rb_define_method(cBucket, "quiet=", cb_bucket_quiet_set, 1);
     rb_define_alias(cBucket, "quiet?", "quiet");
-    id_iv_quiet = rb_intern("@quiet");
 
     /* Document-method: default_flags
      * Default flags for new values.
@@ -2187,9 +3317,9 @@ Init_couchbase_ext(void)
      * @note Amending format bit will also change #default_format value
      *
      * @return [Fixnum] the effective flags */
-    rb_define_attr(cBucket, "default_flags", 1, 1);
+    /* rb_define_attr(cBucket, "default_flags", 1, 1); */
+    rb_define_method(cBucket, "default_flags", cb_bucket_default_flags_get, 0);
     rb_define_method(cBucket, "default_flags=", cb_bucket_default_flags_set, 1);
-    id_iv_default_flags = rb_intern("@default_flags");
 
     /* Document-method: default_format
      * Default format for new values.
@@ -2202,7 +3332,7 @@ Init_couchbase_ext(void)
      * Here is some notes regarding how to choose the format:
      *
      * * <tt>:document</tt> (default) format supports most of ruby types
-     *   which could be mapped to JSON data (hashes, arrays, string,
+     *   which could be mapped to JSON data (hashes, arrays, strings,
      *   numbers). Future version will be able to run map/reduce queries on
      *   the values in the document form (hashes).
      *
@@ -2224,9 +3354,18 @@ Init_couchbase_ext(void)
      * @note Amending default_format will also change #default_flags value
      *
      * @return [Symbol] the effective format */
-    rb_define_attr(cBucket, "default_format", 1, 1);
+    /* rb_define_attr(cBucket, "default_format", 1, 1); */
+    rb_define_method(cBucket, "default_format", cb_bucket_default_format_get, 0);
     rb_define_method(cBucket, "default_format=", cb_bucket_default_format_set, 1);
-    id_iv_default_format = rb_intern("@default_format");
+
+    /* Document-method: timeout
+     * @return [Fixnum] The timeout for the operations. The client will
+     *   raise {Couchbase::Error::Timeout} exception for all commands which
+     *   weren't completed in given timeslot. */
+    /* rb_define_attr(cBucket, "timeout", 1, 1); */
+    rb_define_method(cBucket, "timeout", cb_bucket_timeout_get, 0);
+    rb_define_method(cBucket, "timeout=", cb_bucket_timeout_set, 1);
+
     /* Document-method: on_error
      * Error callback for asynchronous mode.
      *
@@ -2249,54 +3388,44 @@ Init_couchbase_ext(void)
      *   ...
      *
      * @return [Proc] the effective callback */
-    rb_define_attr(cBucket, "on_error", 1, 1);
+    /* rb_define_attr(cBucket, "on_error", 1, 1); */
     rb_define_method(cBucket, "on_error", cb_bucket_on_error_get, 0);
     rb_define_method(cBucket, "on_error=", cb_bucket_on_error_set, 1);
-    id_iv_on_error = rb_intern("@on_error");
-
-    /* Document-method: url
-     * @return [String] the address of the cluster management interface. */
-    rb_define_attr(cBucket, "url", 1, 0);
-    id_iv_url = rb_intern("@url");
-    /* Document-method: hostname
-     * @return [String] the host name of the management interface (default: "localhost") */
-    rb_define_attr(cBucket, "hostname", 1, 0);
-    id_iv_hostname = rb_intern("@hostname");
-    /* Document-method: port
-     * @return [Fixnum] the port number of the management interface (default: 8091) */
-    rb_define_attr(cBucket, "port", 1, 0);
-    id_iv_port = rb_intern("@port");
-    /* Document-method: authority
-     * @return [String] host with port. */
-    rb_define_attr(cBucket, "authority", 1, 0);
-    id_iv_authority = rb_intern("@authority");
-    /* Document-method: bucket
-     * @return [String] the bucket name */
-    rb_define_attr(cBucket, "bucket", 1, 0);
+
+    /* rb_define_attr(cBucket, "url", 1, 0); */
+    rb_define_method(cBucket, "url", cb_bucket_url_get, 0);
+    /* rb_define_attr(cBucket, "hostname", 1, 0); */
+    rb_define_method(cBucket, "hostname", cb_bucket_hostname_get, 0);
+    /* rb_define_attr(cBucket, "port", 1, 0); */
+    rb_define_method(cBucket, "port", cb_bucket_port_get, 0);
+    /* rb_define_attr(cBucket, "authority", 1, 0); */
+    rb_define_method(cBucket, "authority", cb_bucket_authority_get, 0);
+    /* rb_define_attr(cBucket, "bucket", 1, 0); */
+    rb_define_method(cBucket, "bucket", cb_bucket_bucket_get, 0);
     rb_define_alias(cBucket, "name", "bucket");
-    id_iv_bucket = rb_intern("@bucket");
-    /* Document-method: pool
-     * @return [String] the pool name (usually "default") */
-    rb_define_attr(cBucket, "pool", 1, 0);
-    id_iv_pool = rb_intern("@pool");
-    /* Document-method: username
-     * @return [String] the username for protected buckets (usually matches
-     *   the bucket name) */
-    rb_define_attr(cBucket, "username", 1, 0);
-    id_iv_username = rb_intern("@username");
-    /* Document-method: password
-     * @return [String] the password for protected buckets */
-    rb_define_attr(cBucket, "password", 1, 0);
-    id_iv_password = rb_intern("@password");
+    /* rb_define_attr(cBucket, "pool", 1, 0); */
+    rb_define_method(cBucket, "pool", cb_bucket_pool_get, 0);
+    /* rb_define_attr(cBucket, "username", 1, 0); */
+    rb_define_method(cBucket, "username", cb_bucket_username_get, 0);
+    /* rb_define_attr(cBucket, "password", 1, 0); */
+    rb_define_method(cBucket, "password", cb_bucket_password_get, 0);
 
     /* Define symbols */
     id_arity = rb_intern("arity");
     id_call = rb_intern("call");
-    id_load = rb_intern("load");
     id_dump = rb_intern("dump");
     id_flatten_bang = rb_intern("flatten!");
     id_has_key_p = rb_intern("has_key?");
+    id_host = rb_intern("host");
+    id_load = rb_intern("load");
+    id_match = rb_intern("match");
+    id_parse = rb_intern("parse");
+    id_password = rb_intern("password");
+    id_path = rb_intern("path");
+    id_port = rb_intern("port");
+    id_scheme = rb_intern("scheme");
     id_to_s = rb_intern("to_s");
+    id_user = rb_intern("user");
 
     sym_add = ID2SYM(rb_intern("add"));
     sym_append = ID2SYM(rb_intern("append"));
@@ -2306,6 +3435,7 @@ Init_couchbase_ext(void)
     sym_decrement = ID2SYM(rb_intern("decrement"));
     sym_default_flags = ID2SYM(rb_intern("default_flags"));
     sym_default_format = ID2SYM(rb_intern("default_format"));
+    sym_default_ttl = ID2SYM(rb_intern("default_ttl"));
     sym_delete = ID2SYM(rb_intern("delete"));
     sym_document = ID2SYM(rb_intern("document"));
     sym_extended = ID2SYM(rb_intern("extended"));
@@ -2326,7 +3456,9 @@ Init_couchbase_ext(void)
     sym_replace = ID2SYM(rb_intern("replace"));
     sym_set = ID2SYM(rb_intern("set"));
     sym_stats = ID2SYM(rb_intern("stats"));
+    sym_timeout = ID2SYM(rb_intern("timeout"));
     sym_touch = ID2SYM(rb_intern("touch"));
     sym_ttl = ID2SYM(rb_intern("ttl"));
     sym_username = ID2SYM(rb_intern("username"));
+    sym_version = ID2SYM(rb_intern("version"));
 }