better-riak-client 1.0.5

data/lib/riak/client/feature_detection.rb

@@ -0,0 +1,88 @@
+module Riak
+  class Client
+    # Methods that can be used to determine whether certain features
+    # are supported by the Riak node to which the client backend is
+    # connected.
+    #
+    # Backends must implement the "get_server_version" method,
+    # returning a string representing the Riak node's version. This is
+    # implemented on HTTP using the stats resource, and on Protocol
+    # Buffers using the RpbGetServerInfoReq message.
+    module FeatureDetection
+      # Constants representing Riak versions
+      VERSION = {
+        1 => Gem::Version.new("1.0.0"),
+        1.1 => Gem::Version.new("1.1.0"),
+        1.2 => Gem::Version.new("1.2.0")
+      }.freeze
+
+      # @return [String] the version of the Riak node
+      # @abstract
+      def get_server_version
+        raise NotImplementedError
+      end
+
+      # @return [Gem::Version] the version of the Riak node to which
+      #   this backend is connected
+      def server_version
+        @server_version ||= Gem::Version.new(get_server_version)
+      end
+
+      # @return [true,false] whether MapReduce requests can be submitted without
+      #   phases.
+      def mapred_phaseless?
+        at_least? VERSION[1.1]
+      end
+
+      # @return [true,false] whether secondary index queries are
+      #  supported over Protocol Buffers
+      def pb_indexes?
+        at_least? VERSION[1.2]
+      end
+
+      # @return [true,false] whether search queries are supported over
+      #   Protocol Buffers
+      def pb_search?
+        at_least? VERSION[1.2]
+      end
+
+      # @return [true,false] whether conditional fetch/store semantics
+      #   are supported over Protocol Buffers
+      def pb_conditionals?
+        at_least? VERSION[1]
+      end
+
+      # @return [true,false] whether additional quorums and FSM
+      #   controls are available, e.g. primary quorums, basic_quorum,
+      #   notfound_ok
+      def quorum_controls?
+        at_least? VERSION[1]
+      end
+
+      # @return [true,false] whether "not found" responses might
+      #   include vclocks
+      def tombstone_vclocks?
+        at_least? VERSION[1]
+      end
+
+      # @return [true,false] whether partial-fetches (vclock and
+      #   metadata only) are supported over Protocol Buffers
+      def pb_head?
+        at_least? VERSION[1]
+      end
+
+      protected
+      # @return [true,false] whether the server version is the same or
+      #  newer than the requested version
+      def at_least?(version)
+        server_version >= version
+      end
+
+      # Backends should call this when their connection is interrupted
+      # or reset so as to facilitate rolling upgrades
+      def reset_server_version
+        @server_version = nil
+      end
+    end
+  end
+end

data/lib/riak/client/http_backend/configuration.rb

@@ -0,0 +1,211 @@
+
+require 'riak/failed_request'
+require 'riak/client/http_backend'
+require 'riak/link'
+
+module Riak
+  class Client
+    class HTTPBackend
+      # Riak 0.14 provides a root URL that enumerates all of the
+      # HTTP endpoints and their paths.  This module adds methods to
+      # auto-discover those endpoints via the root URL. It also adds
+      # methods for generating URL paths for specific resources.
+      module Configuration
+        # @return [URI] a URL path to the "ping" resource
+        def ping_path
+          path(riak_kv_wm_ping)
+        end
+
+        # @return [URI] a URL path to the "stats" resource
+        def stats_path
+          path(riak_kv_wm_stats)
+        end
+
+        # @return [URI] a URL path to the "mapred" resource
+        # @param options [Hash] query parameters, e.g. chunked=true
+        def mapred_path(options={})
+          path(riak_kv_wm_mapred, options)
+        end
+
+        # @return [URI] a URL path for the "buckets list" resource
+        def bucket_list_path(options={})
+          if new_scheme?
+            path(riak_kv_wm_buckets, options.merge(:buckets => true))
+          else
+            path(riak_kv_wm_raw, options.merge(:buckets => true))
+          end
+        end
+
+        # @return [URI] a URL path for the "bucket properties"
+        #   resource
+        # @param [String] bucket the bucket name
+        def bucket_properties_path(bucket, options={})
+          if new_scheme?
+            path(riak_kv_wm_buckets, escape(bucket), "props", options)
+          else
+            path(riak_kv_wm_raw, escape(bucket), options.merge(:props => true, :keys => false))
+          end
+        end
+
+        # @return [URI] a URL path for the "list keys" resource
+        # @param [String] bucket the bucket whose keys to list
+        # @param [Hash] options query parameters, e.g. keys=stream
+        def key_list_path(bucket, options={:keys => true})
+          if new_scheme?
+            path(riak_kv_wm_buckets, escape(bucket), "keys", options)
+          else
+            path(riak_kv_wm_raw, escape(bucket), options.merge(:props => false))
+          end
+        end
+
+        # @return [URI] a URL path for the "object" resource
+        # @param [String] bucket the bucket of the object
+        # @param [String,nil] key the key of the object, or nil for a
+        #   server-assigned key when using POST
+        def object_path(bucket, key, options={})
+          key = escape(key) if key
+          if new_scheme?
+            path([riak_kv_wm_buckets, escape(bucket), "keys", key, options].compact)
+          else
+            path([riak_kv_wm_raw, escape(bucket), key, options].compact)
+          end
+        end
+
+        # @return [URI] a URL path for the "link-walking" resource
+        # @param [String] bucket the bucket of the origin object
+        # @param [String] key the key of the origin object
+        # @param [Array<WalkSpec>] specs a list of walk specifications
+        #   to traverse
+        def link_walk_path(bucket, key, specs)
+          specs = specs.map {|s| s.to_s }
+          if new_scheme?
+            path(riak_kv_wm_buckets, escape(bucket), "keys", escape(key), *specs)
+          else
+            path(riak_kv_wm_link_walker, escape(bucket), escape(key), *specs)
+          end
+        end
+
+        # @return [URI] a URL path for the "index range query"
+        #   resource
+        # @param [String] bucket the bucket whose index to query
+        # @param [String] index the name of the index to query
+        # @param [String,Integer] start the start of the range
+        # @param [String,Integer] finish the end of the range
+        def index_range_path(bucket, index, start, finish, options={})
+          raise t('indexes_unsupported') unless new_scheme?
+          path(riak_kv_wm_buckets, escape(bucket), "index", escape(index), escape(start.to_s), escape(finish.to_s), options)
+        end
+
+        # @return [URI] a URL path for the "index range query"
+        #   resource
+        # @param [String] bucket the bucket whose index to query
+        # @param [String] index the name of the index to query
+        # @param [String,Integer] start the start of the range
+        # @param [String,Integer] finish the end of the range
+        def index_eq_path(bucket, index, value, options={})
+          raise t('indexes_unsupported') unless new_scheme?
+          path(riak_kv_wm_buckets, escape(bucket), "index", escape(index), escape(value.to_s), options)
+        end
+
+        # @return [URI] a URL path for a Solr query resource
+        # @param [String] index the index to query
+        # @param [String] query the Lucene-style query string
+        # @param [Hash] options additional query options
+        def solr_select_path(index, query, options={})
+          raise t('search_unsupported') unless riak_solr_searcher_wm
+          options = {"q" => query, "wt" => "json"}.merge(options)
+          if index
+            path(riak_solr_searcher_wm, index, 'select', options)
+          else
+            path(riak_solr_searcher_wm, 'select', options)
+          end
+        end
+
+        # @return [URI] a URL path for a Solr update resource
+        # @param [String] index the index to update
+        def solr_update_path(index)
+          raise t('search_unsupported') unless riak_solr_indexer_wm
+          if index
+            path(riak_solr_indexer_wm, index, 'update')
+          else
+            path(riak_solr_indexer_wm, 'update')
+          end
+        end
+
+        # @return [URI] a URL path for the Luwak interface
+        def luwak_path(key)
+          raise t('luwak_unsupported') unless luwak_wm_file
+          if key
+            path(luwak_wm_file, escape(key))
+          else
+            path(luwak_wm_file)
+          end
+        end
+
+        private
+        def server_config
+          @server_config ||= {}.tap do |hash|
+            begin
+              response = get(200, path("/"))
+              Link.parse(response[:headers]['link'].first).each {|l| hash[l.tag.intern] ||= l.url }
+            rescue Riak::FailedRequest
+            end
+          end
+        end
+
+        def new_scheme?
+          !riak_kv_wm_buckets.nil?
+        end
+
+        def get_server_version
+          begin
+            # Attempt to grab the server version from the stats resource
+            stats = send(:stats)
+            stats['riak_kv_version']
+          rescue FailedRequest
+            # If stats is disabled, we can't assume the Riak version
+            # is >= 1.1. However, we can assume the new URL scheme is
+            # at least version 1.0.
+            new_scheme? ? "1.0.0" : "0.14.0"
+          end
+        end
+
+        def riak_kv_wm_buckets
+          server_config[:riak_kv_wm_buckets]
+        end
+
+        def riak_kv_wm_raw
+          server_config[:riak_kv_wm_raw] || node.http_paths[:prefix]
+        end
+
+        def riak_kv_wm_link_walker
+          server_config[:riak_kv_wm_link_walker] || node.http_paths[:prefix]
+        end
+
+        def riak_kv_wm_mapred
+          server_config[:riak_kv_wm_mapred] || node.http_paths[:mapred]
+        end
+
+        def riak_kv_wm_ping
+          server_config[:riak_kv_wm_ping] || "/ping"
+        end
+
+        def riak_kv_wm_stats
+          server_config[:riak_kv_wm_stats] || "/stats"
+        end
+
+        def riak_solr_searcher_wm
+          server_config[:riak_solr_searcher_wm]
+        end
+
+        def riak_solr_indexer_wm
+          server_config[:riak_solr_indexer_wm]
+        end
+
+        def luwak_wm_file
+          server_config[:luwak_wm_file]
+        end
+      end
+    end
+  end
+end

data/lib/riak/client/http_backend/key_streamer.rb

@@ -0,0 +1,43 @@
+require 'riak/util/escape'
+require 'riak/json'
+
+module Riak
+   class Client
+     class HTTPBackend
+       # @private
+       class KeyStreamer
+         include Util::Escape
+
+         def initialize(block)
+           @buffer = ""
+           @block = block
+         end
+
+         def accept(chunk)
+           @buffer << chunk
+           consume
+         end
+
+         def to_proc
+           method(:accept).to_proc
+         end
+
+         private
+         def consume
+           while @buffer =~ /\}\{/
+             stream($~.pre_match + '}')
+             @buffer = '{' + $~.post_match
+           end
+         end
+
+         def stream(str)
+           obj = JSON.parse(str) rescue nil
+           if obj && obj['keys']
+             @block.call obj['keys'].map(&method(:maybe_unescape))
+           end
+         end
+       end
+     end
+   end
+ end
+

data/lib/riak/client/http_backend/object_methods.rb

@@ -0,0 +1,106 @@
+require 'uri'
+require 'set'
+require 'time'
+require 'riak/client/http_backend'
+require 'riak/robject'
+require 'riak/link'
+require 'riak/util/multipart'
+
+module Riak
+  class Client
+    class HTTPBackend
+      # Methods for assisting with the handling of {RObject}s present
+      # in HTTP requests and responses.
+      module ObjectMethods
+        # HTTP header hash that will be sent along when reloading the object
+        # @return [Hash] hash of HTTP headers
+        def reload_headers(robject)
+          {}.tap do |h|
+            h['If-None-Match'] = robject.etag if robject.etag.present?
+            h['If-Modified-Since'] = robject.last_modified.httpdate if robject.last_modified.present?
+          end
+        end
+
+        # HTTP header hash that will be sent along when storing the object
+        # @return [Hash] hash of HTTP Headers
+        def store_headers(robject)
+          {}.tap do |hash|
+            hash["Content-Type"] = robject.content_type
+            hash["X-Riak-Vclock"] = robject.vclock if robject.vclock
+            if robject.prevent_stale_writes && robject.etag.present?
+              hash["If-Match"] = robject.etag
+            elsif robject.prevent_stale_writes
+              hash["If-None-Match"] = "*"
+            end
+            unless robject.links.blank?
+              hash["Link"] = robject.links.reject {|l| l.rel == "up" }.map {|l| l.to_s(new_scheme?) }.join(", ")
+            end
+            unless robject.meta.blank?
+              robject.meta.each do |k,v|
+                hash["X-Riak-Meta-#{k}"] = v.to_s
+              end
+            end
+            unless robject.indexes.blank?
+              robject.indexes.each do |k,v|
+                hash["X-Riak-Index-#{k}"] = v.to_a.sort.map {|i| i.to_s }.join(", ")
+              end
+            end
+          end
+        end
+
+        # Load object data from an HTTP response
+        # @param [Hash] response a response from {Riak::Client::HTTPBackend}
+        def load_object(robject, response)
+          extract_header(robject, response, "location", :key) {|v| URI.unescape(v.match(%r{.*/(.*?)(\?.*)?$})[1]) }
+          extract_header(robject, response, "content-type", :content_type)
+          extract_header(robject, response, "x-riak-vclock", :vclock)
+          extract_header(robject, response, "link", :links) {|v| Set.new(Link.parse(v)) }
+          extract_header(robject, response, "etag", :etag)
+          extract_header(robject, response, "last-modified", :last_modified) {|v| Time.httpdate(v) }
+          robject.meta = response[:headers].inject({}) do |h,(k,v)|
+            if k =~ /x-riak-meta-(.*)/i
+              h[$1] = v
+            end
+            h
+          end
+          robject.indexes = response[:headers].inject(Hash.new {|h,k| h[k] = Set.new }) do |h,(k,v)|
+            if k =~ /x-riak-index-((?:.*)_(?:int|bin))$/i
+              key = $1
+              h[key].merge Array(v).map {|vals| vals.split(/,\s*/).map {|i| key =~ /int$/ ? i.to_i : i } }.flatten
+            end
+            h
+          end
+          robject.conflict = (response[:code] && response[:code].to_i == 300 && robject.content_type =~ /multipart\/mixed/)
+          robject.siblings = robject.conflict? ? extract_siblings(robject, response[:body]) : nil
+          robject.raw_data = response[:body] if response[:body].present? && !robject.conflict?
+
+          robject.conflict? ? robject.attempt_conflict_resolution : robject
+        end
+
+        private
+        def extract_header(robject, response, name, attribute=nil, &block)
+          extract_if_present(robject, response[:headers], name, attribute) do |value|
+            block ? block.call(value[0]) : value[0]
+          end
+        end
+
+        def extract_if_present(robject, hash, key, attribute=nil)
+          if hash[key].present?
+            attribute ||= key
+            value = block_given? ? yield(hash[key]) : hash[key]
+            robject.send("#{attribute}=", value)
+          end
+        end
+
+        def extract_siblings(robject, data)
+          Util::Multipart.parse(data, Util::Multipart.extract_boundary(robject.content_type)).map do |part|
+            RObject.new(robject.bucket, robject.key) do |sibling|
+              load_object(sibling, part)
+              sibling.vclock = robject.vclock
+            end
+          end
+        end
+      end
+    end
+  end
+end