better-riak-client 1.0.5

data/lib/riak/cluster.rb

@@ -0,0 +1,151 @@
+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

data/lib/riak/core_ext/blank.rb

@@ -0,0 +1,53 @@
+require 'set'
+
+unless Object.new.respond_to? :blank?
+  class Object
+    def blank?
+      false
+    end
+  end
+
+  class NilClass
+    def blank?
+      true
+    end
+  end
+
+  class FalseClass
+    def blank?
+      true
+    end
+  end
+
+  class TrueClass
+    def blank?
+      false
+    end
+  end
+
+  class Set
+    alias :blank? :empty?
+  end
+
+  class String
+    def blank?
+      self !~ /[^\s]/
+    end
+  end
+
+  class Array
+    alias :blank? :empty?
+  end
+
+  class Hash
+    alias :blank? :empty?
+  end
+end
+
+unless Object.new.respond_to? :present?
+  class Object
+    def present?
+      !blank?
+    end
+  end
+end

data/lib/riak/core_ext/deep_dup.rb

@@ -0,0 +1,13 @@
+unless {}.respond_to?(:deep_dup)
+  class Hash
+    # Returns a deep copy of hash.
+    def deep_dup
+      duplicate = self.dup
+      duplicate.each_pair do |k,v|
+        tv = duplicate[k]
+        duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
+      end
+      duplicate
+    end
+  end
+end

data/lib/riak/core_ext/extract_options.rb

@@ -0,0 +1,7 @@
+unless Array.new.respond_to? :extract_options!
+  class Array
+    def extract_options!
+      last.is_a?(::Hash) ? pop : {}
+    end
+  end
+end

data/lib/riak/core_ext/json.rb

@@ -0,0 +1,15 @@
+unless Object.new.respond_to?(:to_json)
+  # @private
+  class Object
+    def to_json(*args)
+      Riak::JSON.encode(self)
+    end
+  end
+
+  # @private
+  class Symbol
+    def to_json(*args)
+      to_s.to_json(*args)
+    end
+  end
+end

data/lib/riak/core_ext/slice.rb

@@ -0,0 +1,18 @@
+unless {}.respond_to? :slice
+  class Hash
+    def slice(*keys)
+      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      hash = {}
+      allowed.each { |k| hash[k] = self[k] if has_key?(k) }
+      hash
+    end
+
+    def slice!(*keys)
+      keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+      omit = slice(*self.keys - keys)
+      hash = slice(*keys)
+      replace(hash)
+      omit
+    end
+  end
+end

data/lib/riak/core_ext/stringify_keys.rb

@@ -0,0 +1,10 @@
+unless {}.respond_to? :stringify_keys
+  class Hash
+    def stringify_keys
+      inject({}) do |hash, pair|
+        hash[pair[0].to_s] = pair[1]
+        hash
+      end
+    end
+  end
+end

data/lib/riak/core_ext/symbolize_keys.rb

@@ -0,0 +1,10 @@
+unless {}.respond_to? :symbolize_keys
+  class Hash
+    def symbolize_keys
+      inject({}) do |hash, pair|
+        hash[pair[0].to_sym] = pair[1]
+        hash
+      end
+    end
+  end
+end

data/lib/riak/core_ext/to_param.rb

@@ -0,0 +1,31 @@
+unless Object.new.respond_to? :to_query and Object.new.respond_to? :to_param
+  class Object
+    def to_param
+      to_s
+    end
+
+    def to_query(key)
+      require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+      "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
+    end
+  end
+
+  class Array
+    def to_param
+      map(&:to_param).join('/')
+    end
+
+    def to_query(key)
+      prefix = "#{key}[]"
+      collect { |value| value.to_query(prefix) }.join '&'
+    end
+  end
+
+  class Hash
+    def to_param(namespace = nil)
+      collect do |key, value|
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end.sort * '&'
+    end
+  end
+end

data/lib/riak/core_ext.rb

@@ -0,0 +1,7 @@
+require 'riak/core_ext/blank'
+require 'riak/core_ext/extract_options'
+require 'riak/core_ext/slice'
+require 'riak/core_ext/stringify_keys'
+require 'riak/core_ext/symbolize_keys'
+require 'riak/core_ext/to_param'
+require 'riak/core_ext/deep_dup'

data/lib/riak/encoding.rb

@@ -0,0 +1,6 @@
+if defined? Encoding
+  Encoding.default_internal = "UTF-8" if Encoding.default_internal.nil? ||
+                                        !Encoding.default_internal.ascii_compatible?
+else
+  $KCODE = "U"
+end

data/lib/riak/failed_request.rb

@@ -0,0 +1,81 @@
+
+require 'riak/util/translation'
+require 'riak/json'
+
+module Riak
+  # Exception raised when receiving an unexpected client response from
+  # Riak.
+  class FailedRequest < StandardError
+    include Util::Translation
+
+    def initialize(message)
+      super(message ||  t('failed_request'))
+    end
+  end
+
+  # Exception raised when the expected HTTP response code from Riak
+  # fails to match the actual response code.
+  class HTTPFailedRequest < FailedRequest
+    # @return [Symbol] the HTTP method, one of :head, :get, :post, :put, :delete
+    attr_reader :method
+    # @return [Fixnum] the expected response code
+    attr_reader :expected
+    # @return [Fixnum] the received response code
+    attr_reader :code
+    # @return [Hash] the response headers
+    attr_reader :headers
+    # @return [String] the response body, if present
+    attr_reader :body
+
+    def initialize(method, expected_code, received_code, headers, body)
+      @method, @expected, @code, @headers, @body = method, expected_code, received_code, headers, body
+      super t("http_failed_request", :expected => @expected.inspect, :code => @code, :body => @body)
+    end
+
+    def is_json?
+      headers['content-type'].include?('application/json')
+    end
+
+    # @return [true,false] whether the error represents a "not found" response
+    def not_found?
+      @code.to_i == 404
+    end
+
+    # @return [true,false] whether the error represents an internal
+    #   server error
+    def server_error?
+      @code.to_i == 500
+    end
+  end
+
+  # Exception raised when receiving an unexpected Protocol Buffers response from Riak
+  class ProtobuffsFailedRequest < FailedRequest
+    def initialize(code, message)
+      super t('protobuffs_failed_request', :code => code, :body => message)
+      @original_message = message
+      @not_found = code == :not_found
+      @server_error = code == :server_error
+    end
+
+    # @return [true, false] whether the error response is in JSON
+    def is_json?
+      begin
+        JSON.parse(original_message)
+        true
+      rescue
+        false
+      end
+    end
+
+    # @return [true,false] whether the error represents a "not found" response
+    def not_found?
+      @not_found
+    end
+
+    # @return [true,false] whether the error represents an internal
+    #   server error
+    def server_error?
+      @server_error
+    end
+  end
+end

data/lib/riak/i18n.rb

@@ -0,0 +1,5 @@
+require 'i18n'
+
+Dir.glob(File.expand_path("../locale/*.yml", __FILE__)).each do |locale_file|
+  I18n.load_path << locale_file
+end

data/lib/riak/json.rb

@@ -0,0 +1,52 @@
+require 'multi_json'
+if MultiJson.respond_to?(:adapter)
+  MultiJson.adapter
+else
+  MultiJson.engine # Force loading of an engine
+end
+require 'riak/core_ext/json'
+
+module Riak
+  class << self
+    # Options that will be passed to the JSON parser and encoder.
+    # Defaults to {:max_nesting => 20}
+    attr_accessor :json_options
+  end
+  self.json_options = {:max_nesting => 20}
+
+  # JSON module for internal use inside riak-client
+  module JSON
+    class << self
+      if MultiJson.respond_to?(:dump) # MultiJson 1.2 or later
+        # Parse a JSON string
+        # @param [String] str a JSON payload
+        # @return [Array,Hash] a Ruby object decoded from the JSON payload
+        def parse(str)
+          MultiJson.load(str, Riak.json_options)
+        end
+
+        # Generate a JSON string
+        # @param [Array, Hash] obj an object to JSON-encode
+        # @return [String] a JSON payload
+        def encode(obj)
+          MultiJson.dump(obj)
+        end
+      else
+        # Parse a JSON string
+        # @param [String] str a JSON payload
+        # @return [Array,Hash] a Ruby object decoded from the JSON payload
+        def parse(str)
+          MultiJson.decode(str, Riak.json_options)
+        end
+
+        # Generate a JSON string
+        # @param [Array, Hash] obj an object to JSON-encode
+        # @return [String] a JSON payload
+        def encode(obj)
+          MultiJson.encode(obj)
+        end
+      end
+      alias :dump :encode
+    end
+  end
+end