couchbase 0.9.7

data/lib/couchbase.rb

@@ -0,0 +1,57 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 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.
+#
+
+module Couchbase
+  autoload :Bucket,         'couchbase/bucket'
+  autoload :Couchdb,        'couchbase/couchdb'
+  autoload :Document,       'couchbase/document'
+  autoload :HttpStatus,     'couchbase/http_status'
+  autoload :Latch,          'couchbase/latch'
+  autoload :Memcached,      'couchbase/memcached'
+  autoload :Node,           'couchbase/node'
+  autoload :RestClient,     'couchbase/rest_client'
+  autoload :VERSION,        'couchbase/version'
+  autoload :View,           'couchbase/view'
+
+  # This error is raising when library detects that some operation
+  # doesn't implemented by the server. For example views API doesn't
+  # implemented by Membase 1.7.x
+  class NotImplemented < Exception; end
+
+  class ViewError < Exception
+    attr_reader :from, :reason
+
+    def initialize(from, reason)
+      @from = from
+      @reason = reason
+      super("#{from}: #{reason}")
+    end
+  end
+
+  class << self
+    # The method +new+ initializes new Bucket instance with all arguments passed.
+    #
+    # === Examples
+    #   Couchbase.new("http://localhost:8091/pools/default") #=> establish connection with couchbase default pool and default bucket
+    #   Couchbase.new("http://localhost:8091/pools/default", :bucket_name => 'blog') #=> select custom bucket
+    #   Couchbase.new("http://localhost:8091/pools/default", :bucket_name => 'blog', :bucket_password => 'secret') #=> specify password for bucket (and SASL auth for memcached client)
+    def new(*args)
+      Bucket.new(*args)
+    end
+  end
+
+end

data/lib/couchbase/bucket.rb

@@ -0,0 +1,138 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 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 'uri'
+
+module Couchbase
+
+  # This class in charge of all stuff connected to communication with
+  # Couchbase. It includes CouchDB and Memcached APIs. Also it includes
+  # methods for HTTP transport from RestClient.
+
+  class Bucket
+    include RestClient
+    include Couchdb
+    include Memcached
+
+    attr_accessor :pool_uri, :environment, :type, :nodes,
+      :streaming_uri, :name, :uri, :vbuckets
+
+    # Initializes connection using +pool_uri+ and optional
+    # +:bucket_name+ and +:bucket_password+ (for protected buckets). Bucket
+    # name will be used as a username for all authorizations (SASL for
+    # Memcached API and Basic for HTTP). It also accepts +:environment+
+    # parameter wich intended to let library know what mode it should
+    # use when it applicable (for example it skips/preserves design
+    # documents with 'dev_' prefix for CouchDB API). You can specify
+    # any string starting from 'dev' or 'test' to activate development
+    # mode.
+    #
+    # Also starts thread which will simultanuously listen for
+    # configuration update via +streaming_uri+. Server should push
+    # update notification about adding or removing nodes from cluster.
+    #
+    # Raises ArgumentError when it cannot find specified bucket in given
+    # pool.
+    def initialize(pool_uri, options = {})
+      @latch = Latch.new(:in_progress, :ready)
+      @name = options[:bucket_name] || "default"
+      @pool_uri = URI.parse(pool_uri)
+      @environment = if options[:environment].to_s =~ /^(dev|test)/
+                       :development
+                     else
+                       :production
+                     end
+      config = http_get("#{@pool_uri}/buckets").detect do |bucket|
+                 bucket['name'] == @name
+               end
+      unless config
+        raise ArgumentError,
+          "There no such bucket with name '#{@name}' in pool #{pool_uri}"
+      end
+      @uri = @pool_uri.merge(config['uri'])
+      @streaming_uri = @pool_uri.merge(config['streamingUri'])
+      if password = options[:bucket_password]
+        @credentials = {:username => @name, :password => password}
+      end
+      super
+
+      # Considering all initialization stuff completed and now we can
+      # start config listener
+      listen_for_config_changes
+
+      @latch.wait
+    end
+
+    # Select next node for work with Couchbase. Currently it makes sense
+    # only for couchdb API, because memcached client works using moxi.
+    def next_node
+      nodes.shuffle.first
+    end
+
+    # Perform configuration using configuration cache. It turn all URIs
+    # into full form (with schema, host and port).
+    #
+    # You can override this method in included modules or descendants if
+    # you'd like to reconfigure them when new configuration arrives from
+    # server.
+    def setup(config)
+      @type = config['bucketType']
+      @nodes = config['nodes'].map do |node|
+        Node.new(node['status'],
+                 node['hostname'].split(':').first,
+                 node['ports'],
+                 node['couchApiBase'])
+      end
+      if @type == 'membase'
+        @vbuckets = config['vBucketServerMap']['vBucketMap']
+      end
+      super
+      @latch.toggle
+    end
+
+    private
+
+    # Run background thread to listen for configuration changes.
+    # Rewrites configuration for each update. Curl::Multi uses select()
+    # call when waiting for data, so is should be efficient use ruby
+    # threads here.
+    def listen_for_config_changes
+      Thread.new do
+        multi = Curl::Multi.new
+        multi.add(mk_curl(@streaming_uri.to_s))
+        multi.perform
+      end
+    end
+
+    def mk_curl(url)
+      Curl::Easy.new(url) do |curl|
+        curl.useragent = "couchbase-ruby-client/#{Couchbase::VERSION}"
+        if @credentials
+          curl.http_auth_types = :basic
+          curl.username = @credentials[:username]
+          curl.password = @credentials[:password]
+        end
+        curl.verbose = true if Kernel.respond_to?(:debugger)
+        curl.on_body do |data|
+          config = Yajl::Parser.parse(data)
+          setup(config) if config
+          data.bytesize
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/couchdb.rb

@@ -0,0 +1,107 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 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.
+#
+
+module Couchbase
+  module Couchdb
+
+    # Initializes CouchDB related part of connection.
+    #
+    # @param [ String ] pool_uri Couchbase pool URI.
+    #
+    # @param [ Hash ] options Connection options. This is the hash the client
+    #                         passed to Couchbase.new to start the session
+    def initialize(pool_uri, options = {})
+      super
+    end
+
+    # Fetch design docs stored in current bucket
+    #
+    # @return [ Hash ]
+    def design_docs
+      docs = http_get("#{next_node.couch_api_base}/_all_docs",
+                      :params => {:startkey => "_design/", :endkey => "_design0", :include_docs => true})
+      result = {}
+      docs['rows'].each do |doc|
+        doc = Document.wrap(self, doc)
+        key = doc['_id'].sub(/^_design\//, '')
+        next if @environment == :production && key =~ /dev_/
+        result[key] = doc
+      end
+      result
+    end
+
+    # Update or create design doc with supplied views
+    #
+    # @param [ Hash, IO, String ] data The source object containing JSON
+    #                                  encoded design document. It must have
+    #                                  <tt>_id</tt> key set, this key should
+    #                                  start with <tt>_design/</tt>.
+    #
+    # @return [ Couchbase::Document ] instance
+    def save_design_doc(data)
+      doc = parse_design_document(data)
+      rv = http_put("#{next_node.couch_api_base}/#{doc['_id']}", {}, doc)
+      doc['_rev'] = rv['rev']
+      doc
+    end
+
+    # Fetch all documents from the bucket.
+    #
+    # @param [ Hash ] params Params for CouchDB <tt>/_all_docs</tt> query
+    #
+    # @return [ Couchbase::View ] View object
+    def all_docs(params = {})
+      View.new(self, "#{next_node.couch_api_base}/_all_docs", params)
+    end
+
+    # Delete design doc with given id and revision.
+    #
+    # @param [ String ] id Design document id. It might have '_design/'
+    #                      prefix.
+    #
+    # @param [ String ] rev Document revision. It uses latest revision if
+    #                        <tt>rev</tt> parameter is nil.
+    #
+    def delete_design_doc(id, rev = nil)
+      ddoc = design_docs[id.sub(/^_design\//, '')]
+      return nil unless ddoc
+      http_delete("#{next_node.couch_api_base}/#{ddoc['_id']}",
+                  :params => {:rev => rev || ddoc['_rev']})
+    end
+
+    protected
+
+    def parse_design_document(doc)
+      data = case doc
+             when String
+               Yajl::Parser.parse(doc)
+             when IO
+               Yajl::Parser.parse(doc.read)
+             when Hash
+               doc
+             else
+               raise ArgumentError, "Document should be Hash, String or IO instance"
+             end
+
+      if data['_id'].to_s !~ /^_design\//
+        raise ArgumentError, "'_id' key must be set and start with '_design/'."
+      end
+      data['language'] ||= 'javascript'
+      Document.wrap(self, data)
+    end
+  end
+end

data/lib/couchbase/document.rb

@@ -0,0 +1,71 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 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.
+#
+
+module Couchbase
+  class Document
+    # Undefine as much methods as we can to free names for views
+    instance_methods.each do |m|
+      undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$|^class$|)/
+    end
+
+    attr_accessor :data, :views
+
+    def initialize(connection, data)
+      @data = data
+      @connection = connection
+      @views = []
+      begin
+        if design_doc?
+          data['views'].each do |name, funs|
+            @views << name
+            self.instance_eval <<-EOV, __FILE__, __LINE__ + 1
+              def #{name}(params = {})
+                endpoint = "\#{@connection.next_node.couch_api_base}/\#{@data['_id']}/_view/#{name}"
+                View.new(@connection, endpoint, params)
+              end
+            EOV
+          end
+        end
+      rescue NoMethodError
+      end
+    end
+
+    def self.wrap(connection, data)
+      Document.new(connection, data['doc'] || data)
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def design_doc?
+      !!(@data['_id'] =~ %r(_design/))
+    end
+
+    def has_views?
+      !!(design_doc? && !@views.empty?)
+    end
+
+    def inspect
+      %(#<#{self.class.name}:#{self.object_id} #{@data.inspect}>)
+    end
+  end
+end

data/lib/couchbase/http_status.rb

@@ -0,0 +1,118 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011 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.
+#
+
+module Couchbase
+
+  # This module contains definitions for exceptions which wrap HTTP
+  # errors. Also it collect them in useful structure
+  # +HttpStatus::Errors+ which is map with status code as a key and
+  # exception class as a value. See the usage example below.
+  #
+  # === Example
+  #
+  #   data = Yajl::Parser.parse(curl.body_str)
+  #   if error_class = HttpStatus::Errors[curl.response_code]
+  #     raise error_class.new(data['error'], data['reason'])
+  #   end
+  #
+
+  module HttpStatus
+
+    # Base class for all HTTP error codes. It povides handy methods for
+    # investigating what happened. For example, it stores +status_code+
+    # and human readable +status_message+ automatically and allows to
+    # provide context specific code and message (+error+ and +reason+
+    # correspondingly)
+
+    class Status < Exception
+      class << self
+        attr_accessor :status_code, :status_message
+        alias_method :to_i, :status_code
+
+        def status_line
+          "#{status_code} #{status_message}"
+        end
+      end
+
+      attr_reader :error, :reason
+      def initialize(error, reason)
+        @error = error
+        @reason = reason
+        super("#{error}: #{reason}")
+      end
+
+      def status_code
+        self.class.status_code
+      end
+
+      def status_message
+        self.class.status_message
+      end
+
+      def status_line
+        self.class.status_line
+      end
+
+      def to_i
+        self.class.to_i
+      end
+    end
+
+    StatusMessage = {
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Timeout',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request-URI Too Large',
+      415 => 'Unsupported Media Type',
+      416 => 'Request Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      422 => 'Unprocessable Entity',
+      423 => 'Locked',
+      424 => 'Failed Dependency',
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Timeout',
+      505 => 'HTTP Version Not Supported',
+      507 => 'Insufficient Storage'
+    }
+
+    # Hash with error code as a key and exceptin class as a value
+    Errors = {}
+
+    StatusMessage.each do |status_code, status_message|
+      klass = Class.new(Status)
+      klass.status_code = status_code
+      klass.status_message = status_message
+      klass_name = status_message.gsub(/[ \-]/,'')
+      const_set(klass_name, klass)
+      HttpStatus::Errors[status_code] = const_get(klass_name)
+    end
+  end
+end