riak-client 0.9.8 → 1.0.0.beta

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 
 require 'riak/failed_request'
 require 'riak/client/http_backend'
@@ -21,29 +8,159 @@ module Riak
     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.
+      # 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
+
         private
         def server_config
           @server_config ||= {}.tap do |hash|
             begin
-              response = get(200, "/", {}, {})
-              Link.parse(response[:headers]['link'].first).each {|l| hash[l.tag.intern] = l.url }
+              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 riak_kv_wm_buckets
+          server_config[:riak_kv_wm_buckets]
+        end
+
         def riak_kv_wm_raw
-          server_config[:riak_kv_wm_raw] || client.prefix
+          server_config[:riak_kv_wm_raw] || client.http_paths[:prefix]
         end
 
         def riak_kv_wm_link_walker
-          server_config[:riak_kv_wm_link_walker] || client.prefix
+          server_config[:riak_kv_wm_link_walker] || client.http_paths[:prefix]
         end
 
         def riak_kv_wm_mapred
-          server_config[:riak_kv_wm_mapred] || client.mapred
+          server_config[:riak_kv_wm_mapred] || client.http_paths[:mapred]
         end
 
         def riak_kv_wm_ping
@@ -53,6 +170,14 @@ module Riak
         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
       end
     end
   end

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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
 require 'riak/util/escape'
 require 'riak/json'
 
@@ -46,7 +33,7 @@ module Riak
          def stream(str)
            obj = JSON.parse(str) rescue nil
            if obj && obj['keys']
-             @block.call obj['keys'].map(&method(:unescape))
+             @block.call obj['keys'].map(&method(:maybe_unescape))
            end
          end
        end

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 require 'uri'
 require 'set'
 require 'time'
@@ -46,13 +33,18 @@ module Riak
               hash["If-None-Match"] = "*"
             end
             unless robject.links.blank?
-              hash["Link"] = robject.links.reject {|l| l.rel == "up" }.map(&:to_s).join(", ")
+              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
 
@@ -66,15 +58,23 @@ module Riak
           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-(.*)/
+            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
+
+          robject.conflict? ? robject.attempt_conflict_resolution : robject
         end
 
         private

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 
 require 'riak/util/headers'
 

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

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 
 require 'base64'
 require 'uri'
@@ -33,10 +20,9 @@ module Riak
         #   @param [Hash] headers custom headers to send with the request
         # @return [Hash] response data, containing only the :headers and :code keys
         # @raise [FailedRequest] if the response code doesn't match the expected response
-        def head(expect, *resource)
-          headers = default_headers.merge(resource.extract_options!)
-          verify_path!(resource)
-          perform(:head, path(*resource), headers, expect)
+        def head(expect, resource, headers={})
+          headers = default_headers.merge(headers)
+          perform(:head, resource, headers, expect)
         end
 
         # Performs a GET request to the specified resource on the Riak server.
@@ -53,10 +39,9 @@ module Riak
         #   @return [Hash] response data, containing only the :headers and :code keys
         # @return [Hash] response data, containing :headers, :body, and :code keys
         # @raise [FailedRequest] if the response code doesn't match the expected response
-        def get(expect, *resource, &block)
-          headers = default_headers.merge(resource.extract_options!)
-          verify_path!(resource)
-          perform(:get, path(*resource), headers, expect, &block)
+        def get(expect, resource, headers={}, &block)
+          headers = default_headers.merge(headers)
+          perform(:get, resource, headers, expect, &block)
         end
 
         # Performs a PUT request to the specified resource on the Riak server.
@@ -74,10 +59,10 @@ module Riak
         #   @return [Hash] response data, containing only the :headers and :code keys
         # @return [Hash] response data, containing :headers, :code, and :body keys
         # @raise [FailedRequest] if the response code doesn't match the expected response
-        def put(expect, *resource, &block)
-          headers = default_headers.merge(resource.extract_options!)
-          uri, data = verify_path_and_body!(resource)
-          perform(:put, path(*uri), headers, expect, data, &block)
+        def put(expect, resource, body, headers={}, &block)
+          headers = default_headers.merge(headers)
+          verify_body!(body)
+          perform(:put, resource, headers, expect, body, &block)
         end
 
         # Performs a POST request to the specified resource on the Riak server.
@@ -95,10 +80,10 @@ module Riak
         #   @return [Hash] response data, containing only the :headers and :code keys
         # @return [Hash] response data, containing :headers, :code and :body keys
         # @raise [FailedRequest] if the response code doesn't match the expected response
-        def post(expect, *resource, &block)
-          headers = default_headers.merge(resource.extract_options!)
-          uri, data = verify_path_and_body!(resource)
-          perform(:post, path(*uri), headers, expect, data, &block)
+        def post(expect, resource, body, headers={}, &block)
+          headers = default_headers.merge(headers)
+          verify_body!(body)
+          perform(:post, resource, headers, expect, body, &block)
         end
 
         # Performs a DELETE request to the specified resource on the Riak server.
@@ -115,10 +100,9 @@ module Riak
         #   @return [Hash] response data, containing only the :headers and :code keys
         # @return [Hash] response data, containing :headers, :code and :body keys
         # @raise [FailedRequest] if the response code doesn't match the expected response
-        def delete(expect, *resource, &block)
-          headers = default_headers.merge(resource.extract_options!)
-          verify_path!(resource)
-          perform(:delete, path(*resource), headers, expect, &block)
+        def delete(expect, resource, headers={}, &block)
+          headers = default_headers.merge(headers)
+          perform(:delete, resource, headers, expect, &block)
         end
 
         # Executes requests according to the underlying HTTP client library semantics.
@@ -169,35 +153,13 @@ module Riak
         # @param [Array<String,Hash>] segments a relative path or sequence of path segments and optional query params Hash that will be joined to the root URI
         # @return [URI] an absolute URI for the resource
         def path(*segments)
+          segments = segments.flatten
           query = segments.extract_options!.to_param
           root_uri.merge(segments.join("/").gsub(/\/+/, "/").sub(/^\//, '')).tap do |uri|
             uri.query = query if query.present?
           end
         end
 
-        # Verifies that both a resource path and body are present in the arguments
-        # @param [Array] args the arguments to verify
-        # @raise [ArgumentError] if the body or resource is missing, or if the body is not a String
-        def verify_path_and_body!(args)
-          body = args.pop
-          begin
-            verify_path!(args)
-          rescue ArgumentError
-            raise ArgumentError, t("path_and_body_required")
-          end
-
-          raise ArgumentError, t("request_body_type") unless String === body || body.respond_to?(:read)
-          [args, body]
-        end
-
-        # Verifies that the specified resource is valid
-        # @param [String, Array] resource the resource specification
-        # @raise [ArgumentError] if the resource path is too short
-        def verify_path!(resource)
-          resource = Array(resource).flatten
-          raise ArgumentError, t("resource_path_short") unless resource.length > 1 || resource.include?(@client.mapred)
-        end
-
         # Checks the expected response codes against the actual response code. Use internally when
         # implementing {#perform}.
         # @param [String, Fixnum, Array<String,Fixnum>] expected the expected response code(s)
@@ -217,6 +179,14 @@ module Riak
           method != :head && !valid_response?([204,205,304], code) && !has_block
         end
 
+        # Checks whether the submitted body is valid. That is, it must
+        # be a String or respond to the 'read' method.
+        # @param [String, #read] body the body
+        # @raise [ArgumentError] if the body is of invalid type
+        def verify_body!(body)
+          raise ArgumentError, t('request_body_type') unless String === body || body.respond_to?(:read)
+        end
+
         private
         def response_headers
           Thread.current[:response_headers] ||= Riak::Util::Headers.new

data/lib/riak/client/net_http_backend.rb

@@ -1,16 +1,3 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, 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.
 
 require 'riak/client/http_backend'
 require 'riak/failed_request'
@@ -30,9 +17,20 @@ module Riak
         end
       end
 
+      # Sets the read_timeout applied to Net::HTTP connections
+      # Increase this if you have very long request times.
+      def self.read_timeout=(timeout)
+        @read_timeout = timeout
+      end
+
+      def self.read_timeout
+        @read_timeout ||= 4096
+      end
+
       private
       def perform(method, uri, headers, expect, data=nil) #:nodoc:
         http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = self.class.read_timeout
         configure_ssl(http) if @client.ssl_enabled?
 
         request = Net::HTTP.const_get(method.to_s.capitalize).new(uri.request_uri, headers)