riak-client 1.4.5 → 2.0.0.rc1

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

@@ -1,201 +0,0 @@
-
-require 'base64'
-require 'uri'
-require 'riak/client'
-require 'riak/util/headers'
-
-module Riak
-  class Client
-    class HTTPBackend
-      # Methods related to performing HTTP requests in a consistent
-      # fashion across multiple client libraries. HTTP/1.1 verbs are
-      # presented as methods.
-      module TransportMethods
-        # Performs a HEAD request to the specified resource on the Riak server.
-        # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-        # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-        # @overload head(expect, *resource)
-        # @overload head(expect, *resource, headers)
-        #   Send the request with custom headers
-        #   @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={})
-          headers = default_headers.merge(headers)
-          perform(:head, resource, headers, expect)
-        end
-
-        # Performs a GET request to the specified resource on the Riak server.
-        # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-        # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-        # @overload get(expect, *resource)
-        # @overload get(expect, *resource, headers)
-        #   Send the request with custom headers
-        #   @param [Hash] headers custom headers to send with the request
-        # @overload get(expect, *resource, headers={})
-        #   Stream the response body through the supplied block
-        #   @param [Hash] headers custom headers to send with the request
-        #   @yield [chunk] yields successive chunks of the response body as strings
-        #   @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, 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.
-        # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-        # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-        # @param [String] body the request body to send to the server
-        # @overload put(expect, *resource, body)
-        # @overload put(expect, *resource, body, headers)
-        #   Send the request with custom headers
-        #   @param [Hash] headers custom headers to send with the request
-        # @overload put(expect, *resource, body, headers={})
-        #   Stream the response body through the supplied block
-        #   @param [Hash] headers custom headers to send with the request
-        #   @yield [chunk] yields successive chunks of the response body as strings
-        #   @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, 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.
-        # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-        # @param [String, Array<String>] resource a relative path or array of path segments that will be joined to the root URI
-        # @param [String] body the request body to send to the server
-        # @overload post(expect, *resource, body)
-        # @overload post(expect, *resource, body, headers)
-        #   Send the request with custom headers
-        #   @param [Hash] headers custom headers to send with the request
-        # @overload post(expect, *resource, body, headers={})
-        #   Stream the response body through the supplied block
-        #   @param [Hash] headers custom headers to send with the request
-        #   @yield [chunk] yields successive chunks of the response body as strings
-        #   @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, 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.
-        # @param [Fixnum, Array] expect the expected HTTP response code(s) from Riak
-        # @param [String, Array<String,Hash>] resource a relative path or array of path segments and optional query params Hash that will be joined to the root URI
-        # @overload delete(expect, *resource)
-        # @overload delete(expect, *resource, headers)
-        #   Send the request with custom headers
-        #   @param [Hash] headers custom headers to send with the request
-        # @overload delete(expect, *resource, headers={})
-        #   Stream the response body through the supplied block
-        #   @param [Hash] headers custom headers to send with the request
-        #   @yield [chunk] yields successive chunks of the response body as strings
-        #   @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, headers={}, &block)
-          headers = default_headers.merge(headers)
-          perform(:delete, resource, headers, expect, &block)
-        end
-
-        # Executes requests according to the underlying HTTP client library semantics.
-        # @abstract Subclasses must implement this internal method to perform HTTP requests
-        #           according to the API of their HTTP libraries.
-        # @param [Symbol] method one of :head, :get, :post, :put, :delete
-        # @param [URI] uri the HTTP URI to request
-        # @param [Hash] headers headers to send along with the request
-        # @param [Fixnum, Array] expect the expected response code(s)
-        # @param [String, #read] body the PUT or POST request body
-        # @return [Hash] response data, containing :headers, :code and :body keys. Only :headers and :code should be present when the body is streamed or the method is :head.
-        # @yield [chunk] if the method is not :head, successive chunks of the response body will be yielded as strings
-        # @raise [NotImplementedError] if a subclass does not implement this method
-        def perform(method, uri, headers, expect, body=nil)
-          raise NotImplementedError
-        end
-
-        # Default header hash sent with every request, based on settings in the client
-        # @return [Hash] headers that will be merged with user-specified headers on every request
-        def default_headers
-          {
-            "Accept" => "multipart/mixed, application/json;q=0.7, */*;q=0.5",
-            "X-Riak-ClientId" => client_id
-          }.merge(basic_auth_header)
-        end
-
-        def client_id
-          value = @client.client_id
-          case value
-          when Integer
-            b64encode(value)
-          when String
-            value
-          end
-        end
-
-        def basic_auth_header
-          @node.basic_auth ? {"Authorization" => "Basic #{Base64::encode64(@node.basic_auth)}"} : {}
-        end
-
-        # @return [URI] The calculated root URI for the Riak HTTP endpoint
-        def root_uri
-          protocol = node.ssl_enabled? ? "https" : "http"
-          URI.parse("#{protocol}://#{node.host}:#{node.http_port}")
-        end
-
-        # Calculates an absolute URI from a relative path specification
-        # @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
-
-        # 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)
-        # @param [String, Fixnum] actual the received response code
-        # @return [Boolean] whether the actual response code is acceptable given the expectations
-        def valid_response?(expected, actual)
-          Array(expected).map(&:to_i).include?(actual.to_i)
-        end
-
-        # Checks whether a combination of the HTTP method, response code, and block should
-        # result in returning the :body in the response hash. Use internally when implementing {#perform}.
-        # @param [Symbol] method the HTTP method
-        # @param [String, Fixnum] code the received response code
-        # @param [Boolean] has_block whether a streaming block was passed to {#perform}. Pass block_given? to this parameter.
-        # @return [Boolean] whether to return the body in the response hash
-        def return_body?(method, code, has_block)
-          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
-        end
-
-        def b64encode(n)
-          Base64.encode64([n].pack("N")).chomp
-        end
-      end
-    end
-  end
-end

data/lib/riak/client/instrumentation.rb

@@ -1,25 +0,0 @@
-class Riak::Client
-  include Instrumentable
-
-  client_payload = {protocol: :protocol, client_id: :client_id}
-
-  instrument_method :buckets, 'riak.list_buckets', client_payload
-  instrument_method :list_buckets, 'riak.list_buckets', client_payload
-  instrument_method :list_keys, 'riak.list_keys', client_payload
-  instrument_method :set_bucket_props, 'riak.set_bucket_props', client_payload
-  instrument_method :get_bucket_props, 'riak.get_bucket_props', client_payload
-  instrument_method :clear_bucket_props, 'riak.clear_bucket_props', client_payload
-  instrument_method :get_index, 'riak.get_index', client_payload
-  instrument_method :store_object, 'riak.store_object', client_payload
-  instrument_method :get_object, 'riak.get_object', client_payload
-  instrument_method :reload_object, 'riak.reload_object', client_payload
-  instrument_method :delete_object, 'riak.delete_object', client_payload
-  instrument_method :store_file, 'riak.store_file', client_payload
-  instrument_method :get_file, 'riak.get_file', client_payload
-  instrument_method :delete_file, 'riak.delete_file', client_payload
-  instrument_method :file_exists?, 'riak.file_exists', client_payload
-  instrument_method :file_exist?, 'riak.file_exists', client_payload
-  instrument_method :link_walk, 'riak.link_walk', client_payload
-  instrument_method :mapred, 'riak.map_reduce', client_payload
-  instrument_method :ping, 'riak.ping', client_payload
-end

data/lib/riak/client/net_http_backend.rb

@@ -1,82 +0,0 @@
-require 'riak/client/http_backend'
-require 'riak/failed_request'
-
-module Riak
-  class Client
-    # Uses the Ruby standard library Net::HTTP to connect to Riak.
-    # Conforms to the Riak::Client::HTTPBackend interface.
-    class NetHTTPBackend < HTTPBackend
-      def self.configured?
-        begin
-          require 'net/http'
-          require 'openssl'
-          true
-        rescue LoadError, NameError
-          false
-        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
-
-      # Net::HTTP doesn't use persistent connections, so there's no
-      # work to do here.
-      def teardown; 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 @node.ssl_enabled?
-
-        request = Net::HTTP.const_get(method.to_s.capitalize).new(uri.request_uri, headers)
-        if String === data
-          request.body = data
-        elsif data.respond_to?(:read)
-          case
-          when data.respond_to?(:stat) # IO#stat
-            request.content_length = data.stat.size
-          when data.respond_to?(:size) # Some IO-like objects
-            request.content_length = data.size
-          else
-            request['Transfer-Encoding'] = 'chunked'
-          end
-          request.body_stream = data
-        end
-
-        {}.tap do |result|
-          http.start # Fixes Ruby < 1.8.7p315
-          http.request(request) do |response|
-            unless valid_response?(expect, response.code)
-              raise Riak::HTTPFailedRequest.new(method, expect, response.code.to_i, response.to_hash, response.body)
-            end
-
-            result.merge!({:headers => response.to_hash, :code => response.code.to_i})
-            response.read_body {|chunk| yield chunk } if block_given?
-            if return_body?(method, response.code, block_given?)
-              result[:body] = response.body
-            end
-          end
-        end
-      end
-
-      def configure_ssl(http)
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL.const_get("VERIFY_#{@node.ssl_options[:verify_mode].upcase}")
-        if @node.ssl_options[:pem]
-          http.cert = OpenSSL::X509::Certificate.new(@node.ssl_options[:pem])
-          http.key  = OpenSSL::PKey::RSA.new(@node.ssl_options[:pem], @node.ssl_options[:pem_password])
-        end
-        http.ca_file = @node.ssl_options[:ca_file] if @node.ssl_options[:ca_file]
-        http.ca_path = @node.ssl_options[:ca_path] if @node.ssl_options[:ca_path]
-      end
-    end
-  end
-end

data/lib/riak/cluster.rb

@@ -1,151 +0,0 @@
-require 'pathname'
-require 'riak/node'
-require 'riak/util/translation'
-
-module Riak
-  # Generates and controls a cluster of {Riak::Node} instances for use
-  # in development or testing on a single machine.
-  class Cluster
-    include Util::Translation
-    # @return [Array<Node>] the member Nodes of this cluster
-    attr_reader :nodes
-
-    # @return [Hash] the cluster configuration
-    attr_reader :configuration
-
-    # @return [Pathname] the root directory of the cluster
-    attr_reader :root
-
-    # Creates a {Cluster} of {Node}s.
-    # @param [Hash] config the configuration for the cluster
-    # @option config [Fixnum] :count the number of nodes to create
-    # @option config [String] :source path to the Riak bin/ directory.
-    #   See {Node#source}.
-    # @option config [String] :root path to where the nodes will be
-    #   generated.
-    # @option config [Fixnum] :min_port the base port number from
-    #   which nodes will claim IP ports for HTTP, PB, handoff.
-    def initialize(config={})
-      raise ArgumentError, t('source_and_root_required') unless config[:source] && config[:root]
-      @configuration = config
-      @count = config.delete(:count) || 4
-      @min_port = config.delete(:min_port) || 9000
-      @root = Pathname.new(config.delete(:root))
-      @nodes = []
-      cookie = "#{rand(100000).to_s}_#{rand(1000000).to_s}"
-      @count.times do |i|
-        nodes << Riak::Node.new(config.merge(:min_port => @min_port + (i * 3),
-                                             :root => @root + (i+1).to_s,
-                                             :cookie => cookie))
-      end
-    end
-
-    # @return [true,false] whether the cluster has been created
-    def exist?
-      root.directory? && nodes.all? {|n| n.exist? }
-    end
-
-    # Generates all nodes in the cluster.
-    def create
-      unless exist?
-        root.mkpath unless root.exist?
-        nodes.each {|n| n.create }
-      end
-    end
-
-    # Removes all nodes in the cluster and the root, and freezes the
-    # object.
-    def destroy
-      nodes.each {|n| n.destroy }
-      root.rmtree if root.exist?
-      freeze
-    end
-
-    # Removes and recreates the cluster.
-    def recreate
-      stop unless stopped?
-      root.rmtree if root.exist?
-      create
-    end
-
-    # Drops all data from the cluster without destroying the nodes.
-    def drop
-      nodes.each {|n| n.drop }
-    end
-
-    # Starts all nodes in the cluster.
-    def start
-      nodes.each {|n| n.start }
-    end
-
-    # Stops all nodes in the cluster.
-    def stop
-      nodes.each {|n| n.stop }
-    end
-
-    # Restarts all nodes in the cluster (without exiting the Erlang
-    # runtime)
-    def restart
-      nodes.each {|n| n.restart }
-    end
-
-    # Reboots all nodes in the cluster
-    def reboot
-      nodes.each {|n| n.reboot }
-    end
-
-    # Forces the cluster nodes to restart/reload their JavaScript VMs,
-    # effectively reloading any user-provided code.
-    def js_reload
-      nodes.each {|n| n.js_reload }
-    end
-
-    # Attaches to the console on all nodes, returning a list of
-    # {Riak::Node::Console} objects.
-    # @return [Array<Riak::Node::Console>] consoles for all running
-    #   nodes, with nil for nodes that aren't running or otherwise
-    #   fail to connect
-    def attach
-      nodes.map do |n|
-        begin
-          n.attach
-        rescue ArgumentError, SystemCallError
-          nil
-        end
-      end
-    end
-
-    # Executes the given block on each node against the node's
-    # console. You could use this to send Erlang commands to all nodes
-    # in the cluster.
-    # @yield [console] A block of commands to be run against the
-    #   console
-    # @yieldparam [Riak::Node::Console] console A console manager for
-    #   sending commands to the current node in the iteration
-    def with_console(&block)
-      nodes.each do |n|
-        n.with_console(&block)
-      end
-    end
-
-    # Is the cluster started?
-    def started?
-      nodes.all? {|n| n.started? }
-    end
-
-    # Is the cluster stopped?
-    def stopped?
-      nodes.all? {|n| n.stopped? }
-    end
-
-    # Joins the nodes together into a cluster.
-    # @note This method relies on cluster membership changes present
-    #   in the 1.0 series of Riak, and is NOT safe on 0.14 and
-    #   earlier.
-    def join
-      claimant = nodes.first.name # Not really the claimant, just a
-                                  # node to join to
-      nodes[1..-1].each {|n| n.join(claimant) unless n.peers.include?(claimant) }
-    end
-  end
-end