riak-client 1.4.5 → 2.0.0.rc1

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

@@ -1,15 +0,0 @@
-require 'riak/client/http_backend/chunked_json_streamer'
-
-module Riak
-   class Client
-     class HTTPBackend
-       # @private
-       class BucketStreamer < ChunkedJsonStreamer
-         def get_values(obj)
-           obj['buckets']
-         end
-       end
-     end
-   end
- end
-

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

@@ -1,42 +0,0 @@
-require 'riak/util/escape'
-require 'riak/json'
-
-module Riak
-  class Client
-    class HTTPBackend
-      class ChunkedJsonStreamer
-        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 && get_values(obj)
-             @block.call get_values(obj).map(&method(:maybe_unescape))
-           end
-         end
-       end
-     end
-   end
- end
-

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

@@ -1,227 +0,0 @@
-
-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 options[:stream] && new_scheme?
-            options.delete :stream
-            path(riak_kv_wm_buckets, options.merge(buckets: 'stream'))
-          elsif 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 "counter" resource
-        # @param [String] bucket the bucket of the counter
-        # @param [String] key the key of the counter
-        def counter_path(bucket, key, options={})
-          path([
-                riak_kv_wm_buckets,
-                escape(bucket),
-                "counters",
-                escape(key),
-                options
-                ].compact)
-        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

@@ -1,15 +0,0 @@
-require 'riak/client/http_backend/chunked_json_streamer'
-
-module Riak
-   class Client
-     class HTTPBackend
-       # @private
-       class KeyStreamer < ChunkedJsonStreamer
-         def get_values(obj)
-           obj['keys']
-         end
-       end
-     end
-   end
- end
-

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

@@ -1,114 +0,0 @@
-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, "x-riak-vclock", :vclock)
-          case response[:code] && response[:code].to_i
-          when 304
-            # Resulted from a reload, don't modify anything
-          when 300
-            robject.siblings = extract_siblings(robject, response[:body], response[:headers]['content-type'].first)
-          else
-            robject.siblings = [ load_content(response, RContent.new(robject)) ]
-          end
-          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, content_type)
-          Util::Multipart.parse(data, Util::Multipart.extract_boundary(content_type)).map do |part|
-            RContent.new(robject) do |sibling|
-              load_content(part, sibling)
-            end
-          end
-        end
-
-        def load_content(response, rcontent)
-          extract_header(rcontent, response, "link", :links) {|v| Set.new(Link.parse(v)) }
-          extract_header(rcontent, response, "etag", :etag)
-          extract_header(rcontent, response, "last-modified", :last_modified) {|v| Time.httpdate(v) }
-          extract_header(rcontent, response, "content-type", :content_type)
-          rcontent.meta = response[:headers].inject({}) do |h,(k,v)|
-            if k =~ /x-riak-meta-(.*)/i
-              h[$1] = v
-            end
-            h
-          end
-          rcontent.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
-          rcontent.raw_data = response[:body] if response[:body].present?
-          rcontent
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-
-require 'riak/util/headers'
-
-module Riak
-  class Client
-    class HTTPBackend
-      # @private
-      class RequestHeaders < Riak::Util::Headers
-        alias each each_capitalized
-
-        def initialize(hash)
-          initialize_http_header(hash)
-        end
-
-        def to_a
-          [].tap do |arr|
-            each_capitalized do |k,v|
-              arr << "#{k}: #{v}"
-            end
-          end
-        end
-
-        def to_hash
-          {}.tap do |hash|
-            each_capitalized do |k,v|
-              hash[k] ||= []
-              hash[k] << v
-            end
-          end
-        end
-      end
-    end
-  end
-end