riak-client 1.4.5 → 2.0.0.rc1

data/lib/riak/failed_request.rb

@@ -1,81 +0,0 @@
-
-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/instrumentation.rb

@@ -1,6 +0,0 @@
-begin
-  require 'instrumentable'
-  require 'riak/client/instrumentation'
-rescue LoadError => e
-  # Go quietly into the night...(?)
-end

data/lib/riak/node.rb

@@ -1,40 +0,0 @@
-require 'fileutils'
-
-require 'riak/util/translation'
-require 'riak/node/defaults'
-require 'riak/node/configuration'
-require 'riak/node/generation'
-require 'riak/node/control'
-require 'riak/node/version'
-require 'riak/node/log'
-
-module Riak
-  # A Node encapsulates the generation and management of standalone
-  # Riak nodes. It is used by the {TestServer} to start and manage an
-  # in-memory node for supporting integration test suites.
-  class Node
-    include Util::Translation
-
-    # Creates a new Riak node. Unlike {#new}, this will also generate
-    # the node if it does not exist on disk.  Equivalent to {::new}
-    # followed by {#create}.
-    # @see #new
-    def self.create(configuration={})
-      new(configuration).tap do |node|
-        node.create
-      end
-    end
-
-    # Creates the template for a Riak node. To generate the node after
-    # initialization, use {#create}.
-    def initialize(configuration={})
-      set_defaults
-      configure configuration
-    end
-
-    protected
-    def debug(msg)
-      $stderr.puts msg if ENV["DEBUG_RIAK_NODE"]
-    end
-  end
-end

data/lib/riak/node/configuration.rb

@@ -1,304 +0,0 @@
-require 'pathname'
-require 'yaml'
-
-module Riak
-  class Node
-
-    # do not copy these directories to the test node
-    NODE_DIR_SKIP_LIST = [:data, :pipe]
-
-    # The directories (and accessor methods) that will be created
-    # under the generated node.
-    NODE_DIRECTORIES = [:bin, :etc, :log, :data, :pipe]
-
-    # Makes accessor methods for all the node directories that
-    # return Pathname objects.
-    NODE_DIRECTORIES.each do |dir|
-      class_eval %Q{
-        def #{dir}
-          root + '#{dir}/'
-        end
-      }
-    end
-
-    # @return [Hash] the contents of the Erlang environment, which will
-    #   be created into the app.config file.
-    attr_reader :env
-
-    # @return [Hash] the command-line switches for the Erlang virtual
-    #   machine, which will be created into the vm.args file
-    attr_reader :vm
-
-    # @return [Hash] the configuration that was passed to the Node
-    #   when initialized
-    attr_reader :configuration
-
-    # @return [Array<Pathname>] where user Erlang code will be loaded from
-    def erlang_sources
-      env[:riak_kv][:add_paths].map {|p| Pathname.new(p) }
-    end
-
-    # @return [Pathname] where user Javascript code will be loaded from
-    def javascript_source
-      Pathname.new(env[:riak_kv][:js_source_dir])
-    end
-
-    # @return [Fixnum] the size of the ring, i.e. number of partitions
-    def ring_size
-      env[:riak_core][:ring_creation_size]
-    end
-
-    # @return [Fixnum] The port used for handing off data to other nodes.
-    def handoff_port
-      env[:riak_core][:handoff_port]
-    end
-
-    # @return [Fixnum] The port to which the HTTP API is connected.
-    def http_port
-      # We'll only support 0.14 and later, which uses http rather than web_ip/web_port
-      env[:riak_core][:http][0][1]
-    end
-
-    def pb_config_section
-      return :riak_kv if version < '1.4.0'
-      return :riak_api
-    end
-
-    # @return [Fixnum] the port to which the Protocol Buffers API is connected.
-    def pb_port
-      env[pb_config_section][:pb_port]
-    end
-
-    # @return [String] the interface to which the HTTP API is connected
-    def http_ip
-      env[:riak_core][:http][0][0]
-    end
-
-    # @return [String] the interface to which the Protocol Buffers API is connected
-    def pb_ip
-      env[pb_config_section][:pb_ip]
-    end
-
-    # @return [Symbol] the storage backend for Riak Search.
-    def search_backend
-      env[:riak_search][:search_backend]
-    end
-
-    # @return [Symbol] the storage backend for Riak KV.
-    def kv_backend
-      env[:riak_kv][:storage_backend]
-    end
-
-    # @return [String] the name of the Riak node as seen by distributed Erlang
-    #   communication. AKA "-name" in vm.args.
-    def name
-      vm['-name']
-    end
-
-    # @return [String] the cookie/shared secret used for connecting
-    #    a cluster
-    def cookie
-      vm['-setcookie']
-    end
-
-    # The source of the Riak installation from where the {Node} will
-    # be generated.
-    # @return [Pathname] the source Riak installation
-    attr_reader :source
-
-    # The root directory of the {Node}, where all files are placed
-    # after generation.
-    # @return [Pathname] the root directory of the node
-    attr_reader :root
-
-    def env_script
-      @env_script ||= root + 'lib' + 'env.sh'
-    end
-
-    # The script for starting, stopping and pinging the Node.
-    # @return [Pathname] the path to the control script
-    def control_script
-      @control_script ||= root + 'bin' + control_script_name
-    end
-
-    # The name of the 'riak' control script.
-    def control_script_name
-      @control_script_name ||= 'riak'
-    end
-
-    # The script for controlling non-lifecycle features of Riak like
-    # joining, leaving, status, ringready, etc.
-    # @return [Pathname] the path to the administrative script
-    def admin_script
-      @admin_script ||= root + 'bin' + "#{control_script_name}-admin"
-    end
-
-    # The "manifest" file where the node configuration will be
-    # written.
-    # @return [Pathname] the path to the manifest
-    def manifest
-      root + '.node.yml'
-    end
-
-    protected
-    # Populates the proper node configuration from the input config.
-    def configure(hash)
-      raise ArgumentError, t('source_and_root_required') unless hash[:source] && hash[:root]
-      @configuration = hash
-      configure_paths
-      configure_manifest
-      configure_settings
-      configure_logging
-      configure_data
-      configure_ports(hash[:interface], hash[:min_port])
-      configure_name(hash[:interface])
-    end
-
-    # Reads the manifest if it exists, overrides the passed configuration.
-    def configure_manifest
-      @configuration = YAML.load_file(manifest.to_s) if exist?
-    end
-
-    # Sets the data directories for the various on-disk backends and
-    # the ring state.
-    def configure_data
-      [:bitcask, :eleveldb, :merge_index].each {|k| env[k] ||= {} }
-      env[:bitcask][:data_root] ||= (data + 'bitcask').expand_path.to_s
-      env[:eleveldb][:data_root] ||= (data + 'leveldb').expand_path.to_s
-      env[:merge_index][:data_root] ||= (data + 'merge_index').expand_path.to_s
-      env[:riak_core][:slide_private_dir] ||= (data + 'slide-data').expand_path.to_s
-      env[:riak_core][:ring_state_dir] ||= (data + 'ring').expand_path.to_s
-
-      NODE_DIRECTORIES.each do |dir|
-        env[:riak_core][:"platform_#{dir}_dir"] ||= send(dir).to_s
-      end
-    end
-
-    # Sets directories and handlers for logging.
-    def configure_logging
-      if env[:lager]
-        env[:lager][:handlers] = {
-          :lager_console_backend => :info,
-          :lager_file_backend => [
-                                  Tuple[(log + "error.log").expand_path.to_s, :error],
-                                  Tuple[(log + "console.log").expand_path.to_s, :info]
-                                 ]
-        }
-        env[:lager][:crash_log] = (log + "crash.log").to_s
-      else
-        # TODO: Need a better way to detect this, the defaults point
-        # to 1.0-style configs. Maybe there should be some kind of
-        # detection routine.
-        # Use sasl error logger for 0.14.
-        env[:riak_err] ||= {
-          :term_max_size => 65536,
-          :fmt_max_bytes => 65536
-        }
-        env[:sasl] = {
-          :sasl_error_logger => Tuple[:file, (log + "sasl-error.log").expand_path.to_s],
-          :errlog_type => :error,
-          :error_logger_mf_dir => (log + "sasl").expand_path.to_s,
-          :error_logger_mf_maxbytes => 10485760,
-          :error_logger_mf_maxfiles => 5
-        }
-      end
-      vm['-env ERL_CRASH_DUMP'] =  (log + 'erl_crash.dump').to_s
-    end
-
-    # Sets the node name and cookie for distributed Erlang.
-    def configure_name(interface)
-      interface ||= "127.0.0.1"
-      vm["-name"] ||= configuration[:name] || "riak#{rand(1000000).to_s}@#{interface}"
-      vm["-setcookie"] ||= configuration[:cookie] || "#{rand(100000).to_s}_#{rand(1000000).to_s}"
-    end
-
-    # Merges input configuration with the defaults.
-    def configure_settings
-      @env = deep_merge(env.dup, configuration[:env]) if configuration[:env]
-      @vm = vm.merge(configuration[:vm]) if configuration[:vm]
-    end
-
-    # Sets the source directory and root directory of the generated node.
-    def configure_paths
-      @source = Pathname.new(configuration[:source]).expand_path
-      @root = Pathname.new(configuration[:root]).expand_path
-      # Systems like Homebrew and Stow symlink the scripts into $PATH,
-      # but RUNNER_BASE_DIR is not relative to the symlink.
-      if (@source + control_script_name).symlink?
-        @source = (@source + control_script_name).realpath.parent
-      end
-    end
-
-    # Sets ports and interfaces for http, protocol buffers, and handoff.
-    def configure_ports(interface, min_port)
-      interface ||= "127.0.0.1"
-      min_port ||= 8080
-      unless env[:riak_core][:http]
-        env[:riak_core][:http] = [Tuple[interface, min_port]]
-        min_port += 1
-      end
-      env[:riak_core][:http] = env[:riak_core][:http].map {|pair| Tuple[*pair] }
-      env[pb_config_section][:pb_ip] = interface unless env[pb_config_section][:pb_ip]
-      unless env[pb_config_section][:pb_port]
-        env[pb_config_section][:pb_port] = min_port
-        min_port += 1
-      end
-      unless env[:riak_core][:handoff_port]
-        env[:riak_core][:handoff_port] = min_port
-        min_port += 1
-      end
-    end
-
-    # Implements a deep-merge of two {Hash} instances.
-    # @param [Hash] source the original hash
-    # @param [Hash] target the new hash
-    # @return [Hash] a {Hash} whose {Hash} values have also been merged
-    def deep_merge(source, target)
-      source.merge(target) do |key, old_val, new_val|
-        if Hash === old_val && Hash === new_val
-          deep_merge(old_val, new_val)
-        else
-          new_val
-        end
-      end
-    end
-
-    # This class lets us specify that some settings should be emitted
-    # as Erlang tuples, even though the first element is not
-    # necessarily a Symbol.
-    class Tuple < Array; end
-
-    # Recursively converts a {Hash} into an Erlang configuration
-    # string that is appropriate for the app.config file.
-    # @param [Hash] hash a collection of configuration values
-    # @param [Fixnum] depth the current nesting level of
-    #    generation/indentation
-    # @return [String] Erlang proplists in a String for use in
-    #   app.config
-    def to_erlang_config(hash, depth = 1)
-      padding = '    ' * depth
-      parent_padding = '    ' * (depth-1)
-      values = hash.map do |k,v|
-        "{#{k}, #{value_to_erlang(v, depth)}}"
-      end.join(",\n#{padding}")
-      "[\n#{padding}#{values}\n#{parent_padding}]"
-    end
-
-    # Converts a value to an Erlang term. Mutually recursive with
-    # {#to_erlang_config}.
-    def value_to_erlang(v, depth=1)
-      case v
-      when Hash
-        to_erlang_config(v, depth+1)
-      when String
-        "\"#{v}\""
-      when Tuple
-        "{" << v.map {|i| value_to_erlang(i, depth+1) }.join(", ") << "}"
-      when Array
-        "[" << v.map {|i| value_to_erlang(i, depth+1) }.join(", ") << "]"
-      else
-        v.to_s
-      end
-    end
-  end
-end

data/lib/riak/node/console.rb

@@ -1,133 +0,0 @@
-require 'expect'
-require 'pathname'
-require 'riak/util/translation'
-
-if ENV['DEBUG_RIAK_CONSOLE']
-  $expect_verbose = true
-end
-
-module Riak
-  class Node
-    # Eases working with the Erlang console when attached to the Riak
-    # node.
-    class Console
-      include Util::Translation
-
-      # @return [String] the name of the connected node
-      attr_accessor :nodename
-
-      # Opens a {Console} by connecting to the node.
-      # @return [Console] the opened console
-      def self.open(node)
-        new node.pipe, node.name
-      end
-
-      # Creates a {Console} from the IO pipes connected to the node.
-      # @param [String,Pathname] pipedir path to the pipes opened by
-      #   run_erl
-      # @param [String] nodename the name of the node the Console will
-      #   be attached to
-      def initialize(pipedir, nodename)
-        @nodename = nodename
-        @mutex = Mutex.new
-        @prompt = /\(#{Regexp.escape(nodename)}\)\d+>\s*/
-        pipedir = Pathname(pipedir)
-        pipedir.children.each do |path|
-          if path.pipe?
-            if path.fnmatch("*.r") # Read pipe
-              # debug "Found read pipe: #{path}"
-              @rfile ||= path
-            elsif path.fnmatch("*.w") # Write pipe
-              # debug "Found write pipe: #{path}"
-              @wfile ||= path
-            end
-          else
-            debug "Non-pipe found! #{path}"
-          end
-        end
-        raise ArgumentError, t('no_pipes', :path => pipedir.to_s) if [@rfile, @wfile].any? {|p| p.nil? }
-
-        begin
-          debug "Opening write pipe."
-          @w = open_write_pipe
-          @w.sync = true
-          read_ready = false
-          # Using threads, we get around JRuby's blocking-open
-          # behavior. The main thread pumps the write pipe full of
-          # data so that run_erl will start echoing it into the read
-          # pipe once we have started the open. On non-JVM rubies,
-          # O_NONBLOCK works and we proceed as expected.
-          Thread.new do
-            debug "Opening read pipe."
-            @r = open_read_pipe
-            read_ready = true
-          end
-          Thread.pass
-          @w.print "\n" until read_ready
-          command "ok."
-          debug "Initialized console: #{@r.inspect} #{@w.inspect}"
-        rescue => e
-          debug e.message
-          close
-          raise t('no_pipes', :path => pipedir.to_s) + "[ #{e.message} ]"
-        end
-      end
-
-      # Sends an Erlang command to the console
-      # @param [String] cmd an Erlang expression to send to the node
-      def command(cmd)
-        @mutex.synchronize do
-          begin
-            debug "Sending command #{cmd.inspect}"
-            @w.print "#{cmd}\n"
-            wait_for_erlang_prompt
-          rescue SystemCallError
-            close
-          end
-        end
-      end
-
-      # Detects whether the console connection is still open, that is,
-      # if the node hasn't disconnected from the other side of the
-      # pipe.
-      def open?
-        (@r && !@r.closed?) && (@w && !@w.closed?)
-      end
-
-      # Scans the output of the console until an Erlang shell prompt
-      # is found. Called by {#command} to ensure that the submitted
-      # command succeeds.
-      def wait_for_erlang_prompt
-        wait_for @prompt
-      end
-
-      # Scans the output of the console for the given pattern.
-      # @param [String, Regexp] pattern the pattern to scan for
-      def wait_for(pattern)
-        debug "Scanning for #{pattern.inspect}"
-        @r.expect(pattern)
-      end
-
-      # Closes the console by detaching from the pipes.
-      def close
-        @r.close if @r && !@r.closed?
-        @w.close if @w && !@w.closed?
-        freeze
-      end
-
-      protected
-
-      def debug(msg)
-        $stderr.puts msg if ENV["DEBUG_RIAK_CONSOLE"]
-      end
-
-      def open_write_pipe
-        @wfile.open(File::WRONLY|File::NONBLOCK)
-      end
-
-      def open_read_pipe
-        @rfile.open(File::RDONLY|File::NONBLOCK)
-      end
-    end
-  end
-end