couchbase 1.1.5 → 1.2.0.beta

data/ext/couchbase_ext/version.c

@@ -0,0 +1,147 @@
+/* vim: ft=c et ts=8 sts=4 sw=4 cino=
+ *
+ *   Copyright 2011, 2012 Couchbase, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "couchbase_ext.h"
+
+    void
+version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_version_resp_t *resp)
+{
+    struct context_st *ctx = (struct context_st *)cookie;
+    struct bucket_st *bucket = ctx->bucket;
+    VALUE node, val, *rv = ctx->rv, exc, res;
+
+    node = resp->v.v0.server_endpoint ? STR_NEW_CSTR(resp->v.v0.server_endpoint) : Qnil;
+    exc = cb_check_error(error, "failed to get version", node);
+    if (exc != Qnil) {
+        rb_ivar_set(exc, id_iv_operation, sym_version);
+        if (NIL_P(ctx->exception)) {
+            ctx->exception = cb_gc_protect(bucket, exc);
+        }
+    }
+
+    if (node != Qnil) {
+        val = STR_NEW((const char*)resp->v.v0.vstring, resp->v.v0.nvstring);
+        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, val);
+                cb_proc_call(ctx->proc, 1, res);
+            }
+        } else {                /* synchronous */
+            if (NIL_P(exc)) {
+                rb_hash_aset(*rv, node, val);
+            }
+        }
+    } else {
+        ctx->nqueries--;
+        cb_gc_unprotect(bucket, ctx->proc);
+    }
+
+    (void)handle;
+}
+
+/*
+ * Returns versions of the server for each node in the cluster
+ *
+ * @since 1.1.0
+ *
+ * @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
+ */
+    VALUE
+cb_bucket_version(int argc, VALUE *argv, VALUE self)
+{
+    struct bucket_st *bucket = DATA_PTR(self);
+    struct context_st *ctx;
+    VALUE rv, exc, args, proc;
+    lcb_error_t err;
+    struct params_st params;
+
+    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");
+    }
+    memset(&params, 0, sizeof(struct params_st));
+    params.type = cmd_version;
+    params.bucket = bucket;
+    cb_params_build(&params, RARRAY_LEN(args), args);
+    ctx = xcalloc(1, sizeof(struct context_st));
+    if (ctx == NULL) {
+        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+    }
+    rv = rb_hash_new();
+    ctx->rv = &rv;
+    ctx->bucket = bucket;
+    ctx->exception = Qnil;
+    ctx->proc = cb_gc_protect(bucket, proc);
+    ctx->nqueries = params.cmd.version.num;
+    err = lcb_server_versions(bucket->handle, (const void *)ctx,
+            params.cmd.version.num, params.cmd.version.ptr);
+    exc = cb_check_error(err, "failed to schedule version request", Qnil);
+    cb_params_destroy(&params);
+    if (exc != Qnil) {
+        xfree(ctx);
+        rb_exc_raise(exc);
+    }
+    bucket->nbytes += params.npayload;
+    if (bucket->async) {
+        maybe_do_loop(bucket);
+        return Qnil;
+    } else {
+        if (ctx->nqueries > 0) {
+            /* we have some operations pending */
+            lcb_wait(bucket->handle);
+        }
+        exc = ctx->exception;
+        xfree(ctx);
+        if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
+            rb_exc_raise(exc);
+        }
+        if (bucket->exception != Qnil) {
+            rb_exc_raise(bucket->exception);
+        }
+        return rv;
+    }
+}
+
+

data/lib/action_dispatch/middleware/session/couchbase_store.rb

@@ -0,0 +1,38 @@
+require 'active_support/cache'
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/couchbase'
+require 'couchbase'
+
+module ActionDispatch
+  module Session
+
+    # This is Couchbase-powered session store for Rails applications
+    #
+    # To use it just update your `config/initializers/session_store.rb` file
+    #
+    #   require 'action_dispatch/middleware/session/couchbase_store'
+    #   AppName::Application.config.session_store :couchbase_store
+    #
+    # Or remove this file and add following line to your `config/application.rb`:
+    #
+    #   require 'action_dispatch/middleware/session/couchbase_store'
+    #   config.session_storage = :couchbase_store
+    #
+    # You can also pass additional options:
+    #
+    #   require 'action_dispatch/middleware/session/couchbase_store'
+    #   session_options = {
+    #     :expire_after => 5.minutes,
+    #     :couchbase => {:bucket => "sessions", :default_format => :marshal}
+    #   }
+    #   config.session_storage = :couchbase_store, session_options
+    #
+    # By default sessions will be serialized to JSON, to allow analyse them
+    # using Map/Reduce.
+    #
+    class CouchbaseStore < Rack::Session::Couchbase
+      include Compatibility
+      include StaleSessionCheck
+    end
+  end
+end

data/lib/active_support/cache/couchbase_store.rb

@@ -0,0 +1,356 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011, 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'couchbase'
+require 'securerandom'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/cache'
+
+module ActiveSupport
+  module Cache
+    # This class implements Cache interface for Rails. To use it just
+    # put following line in your config/application.rb file:
+    #
+    #   config.cache_store = :couchbase_store
+    #
+    # You can also pass additional connection options there
+    #
+    #   cache_options = {
+    #     :bucket => 'protected',
+    #     :username => 'protected',
+    #     :password => 'secret',
+    #     :expires_in => 30.seconds
+    #   }
+    #   config.cache_store = :couchbase_store, cache_options
+    class CouchbaseStore < Store
+
+      # Creates a new CouchbaseStore object, with the given options. For
+      # more info see {{Couchbase::Bucket#initialize}}
+      #
+      #   ActiveSupport::Cache::CouchbaseStore.new(:bucket => "cache")
+      #
+      # If no options are specified, then CouchbaseStore will connect to
+      # localhost port 8091 (default Couchbase Server port) and will use
+      # bucket named "default" which is always open for unauthorized access
+      # (if exists).
+      def initialize(*args)
+        args = [*(args.flatten)]
+        options = args.extract_options! || {}
+        @raise_errors = !options[:quiet] = !options.delete(:raise_errors)
+        options[:default_ttl] ||= options.delete(:expires_in)
+        options[:default_format] ||= :marshal
+        options[:key_prefix] ||= options.delete(:namespace)
+        args.push(options)
+        @data = ::Couchbase::Bucket.new(*args)
+      end
+
+      # Fetches data from the cache, using the given key.
+      #
+      # @since 1.2.0.dp5
+      #
+      # If there is data in the cache with the given key, then that data is
+      # returned. If there is no such data in the cache (a cache miss),
+      # then nil will be returned. However, if a block has been passed, that
+      # block will be run in the event of a cache miss. The return value of
+      # the block will be written to the cache under the given cache key,
+      # and that return value will be returned.
+      #
+      # @param [String] name name for the key
+      # @param [Hash] options
+      # @option options [true, false] :force if this option is +true+ it
+      #   will force cache miss.
+      # @option options [Fixnum] :expires_in the expiration time on the
+      #   cache in seconds. Values larger than 30*24*60*60 seconds (30 days)
+      #   are interpreted as absolute times (from the epoch).
+      # @option options [true, false] :unless_exists if this option is +true+
+      #   it will write value only if the key doesn't exist in the database
+      #   (it accepts +:unless_exist+ too).
+      #
+      # @return [Object]
+      def fetch(name, options = nil)
+        options ||= {}
+        name = expanded_key(name)
+
+        if block_given?
+          unless options[:force]
+            entry = instrument(:read, name, options) do |payload|
+              payload[:super_operation] = :fetch if payload
+              read_entry(name, options)
+            end
+          end
+
+          if !entry.nil?
+            instrument(:fetch_hit, name, options) { |payload| }
+            entry
+          else
+            result = instrument(:generate, name, options) do |payload|
+              yield
+            end
+            write(name, result, options)
+            result
+          end
+        else
+          read(name, options)
+        end
+      end
+
+      # Writes the value to the cache, with the key
+      #
+      # @since 1.2.0.dp5
+      #
+      # @param [String] name name for the key
+      # @param [Object] value value of the key
+      # @param [Hash] options
+      # @option options [Fixnum] :expires_in the expiration time on the
+      #   cache in seconds. Values larger than 30*24*60*60 seconds (30 days)
+      #   are interpreted as absolute times (from the epoch).
+      #
+      # @return [Fixnum, false] false in case of failure and CAS value
+      #   otherwise (it could be used as true value)
+      def write(name, value, options = nil)
+        options ||= {}
+        name = expanded_key name
+        if options.delete(:raw)
+          options[:format] = :plain
+          value = value.to_s
+          value.force_encoding(Encoding::BINARY) if defined?(Encoding)
+        end
+
+        instrument(:write, name, options) do |payload|
+          write_entry(name, value, options)
+        end
+      end
+
+      # Fetches data from the cache, using the given key.
+      #
+      # @since 1.2.0.dp5
+      #
+      # If there is data in the cache with the given key, then that data is
+      # returned.  Otherwise, nil is returned.
+      #
+      # @param [String] name name for the key
+      # @param [Hash] options
+      # @option options [Fixnum] :expires_in the expiration time on the
+      #   cache in seconds. Values larger than 30*24*60*60 seconds (30 days)
+      #   are interpreted as absolute times (from the epoch).
+      # @option options [true, false] :raw do not marshal the value if this
+      #   option is +true+
+      #
+      # @return [Object]
+      def read(name, options = nil)
+        options ||= {}
+        name = expanded_key name
+        if options.delete(:raw)
+          options[:format] = :plain
+        end
+
+        instrument(:read, name, options) do |payload|
+          entry = read_entry(name, options)
+          payload[:hit] = !!entry if payload
+          entry
+        end
+      end
+
+      # Read multiple values at once from the cache.
+      #
+      # @since 1.2.0.dp5
+      #
+      # Options can be passed in the last argument.
+      #
+      # Returns a hash mapping the names provided to the values found.
+      #
+      # @return [Hash] key-value pairs
+      def read_multi(*names)
+        options = names.extract_options!
+        names = names.flatten.map{|name| expanded_key(name)}
+        options[:assemble_hash] = true
+        if options.delete(:raw)
+          options[:format] = :plain
+        end
+        instrument(:read_multi, names, options) do
+          @data.get(names, options)
+        end
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        false
+      end
+
+      # Return true if the cache contains an entry for the given key.
+      #
+      # @since 1.2.0.dp5
+      #
+      # @return [true, false]
+      def exists?(name, options = nil)
+        options ||= {}
+        name = expanded_key name
+
+        instrument(:exists?, name) do
+          !read_entry(name, options).nil?
+        end
+      end
+      alias :exist? :exists?
+
+      # Deletes an entry in the cache.
+      #
+      # @since 1.2.0.dp5
+      #
+      # @return [true, false] true if an entry is deleted
+      def delete(name, options = nil)
+        options ||= {}
+        name = expanded_key name
+
+        instrument(:delete, name) do
+          delete_entry(name, options)
+        end
+      end
+
+      # Increment an integer value in the cache.
+      #
+      # @since 1.2.0.dp5
+      #
+      # @param [String] name name for the key
+      # @param [Fixnum] amount (1) the delta value
+      # @param [Hash] options
+      # @option options [Fixnum] :expires_in the expiration time on the
+      #   cache in seconds. Values larger than 30*24*60*60 seconds (30 days)
+      #   are interpreted as absolute times (from the epoch).
+      # @option options [Fixnum] :initial (1) this option allows to initialize
+      #   the value if the key is missing in the cache
+      #
+      # @return [Fixnum] new value
+      def increment(name, amount = 1, options = nil)
+        options ||= {}
+        name = expanded_key name
+
+        if ttl = options.delete(:expires_in)
+          options[:ttl] ||= ttl
+        end
+        options[:create] = true
+        instrument(:increment, name, options) do |payload|
+          payload[:amount] = amount if payload
+          @data.incr(name, amount, options)
+        end
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        false
+      end
+
+      # Decrement an integer value in the cache.
+      #
+      # @since 1.2.0.dp5
+      #
+      # @param [String] name name for the key
+      # @param [Fixnum] amount (1) the delta value
+      # @param [Hash] options
+      # @option options [Fixnum] :expires_in the expiration time on the
+      #   cache in seconds. Values larger than 30*24*60*60 seconds (30 days)
+      #   are interpreted as absolute times (from the epoch).
+      # @option options [Fixnum] :initial this option allows to initialize
+      #   the value if the key is missing in the cache
+      #
+      # @return [Fixnum] new value
+      def decrement(name, amount = 1, options = nil)
+        options ||= {}
+        name = expanded_key name
+
+        if ttl = options.delete(:expires_in)
+          options[:ttl] ||= ttl
+        end
+        options[:create] = true
+        instrument(:decrement, name, options) do |payload|
+          payload[:amount] = amount if payload
+          @data.decr(name, amount, options)
+        end
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        false
+      end
+
+      # Get the statistics from the memcached servers.
+      #
+      # @since 1.2.0.dp5
+      #
+      # @return [Hash]
+      def stats(*arg)
+        @data.stats(*arg)
+      end
+
+      protected
+
+      # Read an entry from the cache.
+      def read_entry(key, options) # :nodoc:
+        @data.get(key, options)
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        nil
+      end
+
+      # Write an entry to the cache.
+      def write_entry(key, value, options) # :nodoc:
+        method = if options[:unless_exists] || options[:unless_exist]
+                   :add
+                 else
+                   :set
+                 end
+        if ttl = options.delete(:expires_in)
+          options[:ttl] ||= ttl
+        end
+        @data.send(method, key, value, options)
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        false
+      end
+
+      # Delete an entry from the cache.
+      def delete_entry(key, options) # :nodoc:
+        @data.delete(key, options)
+      rescue Couchbase::Error::Base => e
+        logger.error("#{e.class}: #{e.message}") if logger
+        raise if @raise_errors
+        false
+      end
+
+      private
+
+      # Expand key to be a consistent string value. Invoke +cache_key+ if
+      # object responds to +cache_key+. Otherwise, to_param method will be
+      # called. If the key is a Hash, then keys will be sorted alphabetically.
+      def expanded_key(key) # :nodoc:
+        return key.cache_key.to_s if key.respond_to?(:cache_key)
+
+        case key
+        when Array
+          if key.size > 1
+            key = key.collect{|element| expanded_key(element)}
+          else
+            key = key.first
+          end
+        when Hash
+          key = key.sort_by { |k,_| k.to_s }.collect{|k,v| "#{k}=#{v}"}
+        end
+
+        key.respond_to?(:to_param) ? key.to_param : key
+      end
+
+    end
+  end
+end