riak-client-noenc 1.0.0

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/errors/backend_creation.rb

@@ -0,0 +1,9 @@
+require 'riak/errors/base'
+
+module Riak
+  class BackendCreationError < Error
+    def initialize(backend)
+      super t('protobuffs_configuration', backend: backend)
+    end
+  end
+end

data/lib/riak/errors/base.rb

@@ -0,0 +1,9 @@
+module Riak
+
+  # Superclass for all errors raised by riak-client. If you catch an error
+  # that the client raises that isn't descended from this class, please
+  # file a bug. Thanks!
+  class Error < StandardError
+    include Util::Translation
+  end
+end

data/lib/riak/errors/connection_error.rb

@@ -0,0 +1,50 @@
+require 'riak/errors/base'
+
+module Riak
+  class ConnectionError < Error
+  end
+
+  class TlsError < ConnectionError
+    class SslVersionConfigurationError < TlsError
+      def initialize
+        super t('ssl.version_configuration_error')
+      end
+    end
+
+    class CertHostMismatchError < TlsError
+      def initialize
+        super t('ssl.cert_host_mismatch')
+      end
+    end
+
+    class CertNotValidError < TlsError
+      def initialize
+        super t('ssl.cert_not_valid')
+      end
+    end
+
+    class CertRevokedError < TlsError
+      def initialize
+        super t('ssl.cert_revoked')
+      end
+    end
+
+    class ReadDataError < TlsError
+      def initialize(actual, candidate)
+        super t('ssl.read_data_error', actual: actual, candidate: candidate)
+      end
+    end
+
+    class UnknownKeyTypeError < TlsError
+      def initialize
+        super t('ssl.unknown_key_type')
+      end
+    end
+  end
+
+  class UserConfigurationError < ConnectionError
+    def initialize
+      super t('pbc.user_not_username')
+    end
+  end
+end

data/lib/riak/errors/crdt_error.rb

@@ -0,0 +1,38 @@
+require 'riak/errors/base'
+
+module Riak
+  class CrdtError < Error
+
+    class SetRemovalWithoutContextError < CrdtError
+      def initialize
+        super t('crdt.set_removal_without_context')
+      end
+    end
+
+    class PreconditionError < CrdtError
+      def initialize(message)
+        super t('crdt.precondition', message: message)
+      end
+    end
+
+    class UnrecognizedDataType < CrdtError
+      def initialize(given_type)
+        super t('crdt.unrecognized_type', type: given_type)
+      end
+    end
+
+    class UnexpectedDataType < CrdtError
+      def initialize(given_type, expected_type)
+        super t('crdt.unexpected_type',
+                given: given_type,
+                expected: expected_type)
+      end
+    end
+
+    class NotACrdt < CrdtError
+      def initialize
+        super t('crdt.not_a_crdt')
+      end
+    end
+  end
+end

data/lib/riak/errors/failed_request.rb

@@ -0,0 +1,58 @@
+require 'riak/errors/base'
+
+module Riak
+  class FailedRequest < Error
+    def initialize(message)
+      super(message ||  t('failed_request'))
+    end
+  end
+
+  # Exception raised when receiving an unexpected Protocol Buffers response from Riak
+  class ProtobuffsFailedRequest < FailedRequest
+    attr_reader :code, :original_message
+    def initialize(code, message)
+      super t('protobuffs_failed_request', :code => code, :body => message)
+      @original_message = message
+      @code = code
+      @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
+
+    def body
+      @original_message
+    end
+  end
+
+  class ProtobuffsUnexpectedResponse < ProtobuffsFailedRequest
+    def initialize(code, expected)
+      super code, t('pbc.unexpected_response', expected: expected, actual: code)
+    end
+  end
+
+  class ProtobuffsErrorResponse < ProtobuffsFailedRequest
+    def initialize(payload)
+      super payload.errcode, payload.errmsg
+    end
+  end
+end

data/lib/riak/errors/protobuffs_error.rb

@@ -0,0 +1,11 @@
+require 'riak/errors/base'
+module Riak
+  class ProtobuffsError < Error
+  end
+
+  class ProtobuffsFailedHeader < ProtobuffsError
+    def initialize
+      super t('pbc.failed_header')
+    end
+  end
+end

data/lib/riak/errors/search_error.rb

@@ -0,0 +1,35 @@
+require 'riak/errors/base'
+
+module Riak
+  class SearchError < Error
+    class IndexExistsError < SearchError
+      def initialize(name)
+        super t('search.index_exists', name: name)
+      end
+    end
+
+    class SchemaExistsError < SearchError
+      def initialize(name)
+        super t('search.schema_exists', name: name)
+      end
+    end
+
+    class IndexArgumentError < SearchError
+      def initialize(index)
+        super t('search.index_argument_error', index: index)
+      end
+    end
+
+    class IndexNonExistError < SearchError
+      def initialize(index)
+        super t('search.index_non_exist', index: index)
+      end
+    end
+
+    class UnexpectedResultError < SearchError
+      def initialize(expected, actual)
+        super t('search.unexpected_result', expected: expected, actual: actual)
+      end
+    end
+  end
+end

data/lib/riak/i18n.rb

@@ -0,0 +1,7 @@
+require 'i18n'
+
+I18n.config.enforce_available_locales = true unless I18n.config.enforce_available_locales == false
+
+Dir.glob(File.expand_path("../locale/*.yml", __FILE__)).each do |locale_file|
+  I18n.load_path << locale_file
+end

data/lib/riak/index_collection.rb

@@ -0,0 +1,71 @@
+module Riak
+
+  # IndexCollection provides extra tools for managing index matches returned by
+  # a Secondary Index query. In Riak 1.4, these queries can be paginaged, and
+  # match keys up with the index values they matched against.
+  class IndexCollection < Array
+
+    # @return [String] The continuation used to retrieve the next page of a
+    # paginated query.
+    attr_accessor :continuation
+
+    # @return [Hash<Integer/String, String>] A hash of index keys (String or
+    # Integer, depending on whether the query was a binary or integer) to
+    # arrays of keys.
+    attr_accessor :with_terms
+
+    def self.new_from_json(json)
+      parsed = JSON.parse json
+      fresh = nil
+      if parsed['keys']
+        fresh = new parsed['keys']
+      elsif parsed['results']
+        fresh_terms = load_json_terms(parsed)
+        fresh = new fresh_terms.values.flatten
+        fresh.with_terms = fresh_terms
+      else
+        fresh = new []
+      end
+      fresh.continuation = parsed['continuation']
+
+      fresh
+    end
+
+    def self.new_from_protobuf(message)
+      fresh = nil
+      if message.keys
+        fresh = new message.keys
+      elsif message.results
+        fresh_terms = load_pb_terms(message)
+        fresh = new fresh_terms.values.flatten
+        fresh.with_terms = fresh_terms
+      else
+        fresh = new
+      end
+      fresh.continuation = message.continuation
+
+      fresh
+    end
+
+    private
+    def self.load_json_terms(parsed)
+      fresh_terms = Hash.new{Array.new}
+      parsed['results'].each do |r|
+        k = r.keys.first
+        v = r[k]
+        fresh_terms[k] += [v]
+      end
+
+      fresh_terms
+    end
+
+    def self.load_pb_terms(message)
+      fresh_terms = Hash.new{Array.new}
+      message.results.each do |r|
+        fresh_terms[r.key] += [r.value]
+      end
+
+      fresh_terms
+    end
+  end
+end

data/lib/riak/instrumentation.rb

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

data/lib/riak/link.rb

@@ -0,0 +1,96 @@
+
+require 'riak/util/translation'
+require 'riak/util/escape'
+require 'riak/walk_spec'
+
+module Riak
+  # Represents a link from one object to another in Riak
+  class Link
+    include Util::Translation
+    include Util::Escape
+
+    # @return [String] the relationship tag (or "rel") of the other resource to this one
+    attr_accessor :tag
+    alias_method :rel, :tag
+    alias_method :rel=, :tag=
+
+    # @return [String] the bucket of the related resource
+    attr_accessor :bucket
+
+    # @return [String] the key of the related resource
+    attr_accessor :key
+
+    %w{bucket key}.each do |m|
+      define_method("#{m}=") { |value|
+        @url = nil
+        instance_variable_set("@#{m}", value)
+      }
+    end
+
+    # @param [String] header_string the string value of the Link: HTTP header from a Riak response
+    # @return [Array<Link>] an array of Riak::Link structs parsed from the header
+    def self.parse(header_string)
+      header_string.scan(%r{<([^>]+)>\s*;\s*(?:rel|riaktag)=\"([^\"]+)\"}).map do |match|
+        new(match[0], match[1])
+      end
+    end
+
+    # @overload initialize(url, tag)
+    #   @param [String] url the url of the related resource
+    #   @param [String] tag the tag for the related resource
+    # @overload initialize(bucket, key, tag)
+    #   @param [String] bucket the bucket of the related resource
+    #   @param [String] key the key of the related resource
+    #   @param [String] tag the tag for the related resource
+    def initialize(*args)
+      raise ArgumentError unless (2..3).include?(args.size)
+      if args.size == 2
+        self.url, @tag = args
+      else
+        @bucket, @key, @tag = args
+      end
+    end
+
+    # @return [String] the URL (relative or absolute) of the related resource
+    def url(new_scheme = false)
+      return @url unless @bucket
+
+      if new_scheme
+        "/buckets/#{escape(bucket)}" + (key.blank? ? "" : "/keys/#{escape(key)}")
+      else
+        "/riak/#{escape(bucket)}" + (key.blank? ? "" : "/#{escape(key)}")
+      end
+    end
+
+    def url=(value)
+      @url = value
+      @bucket = unescape($1) if value =~ %r{^/buckets/([^/]+)/?} || value =~ %r{^/[^/]+/([^/]+)/?}
+      @key = unescape($1) if value =~ %r{^/buckets/[^/]+/keys/([^/]+)/?} || value =~ %r{^/[^/]+/[^/]+/([^/]+)/?}
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s(new_scheme = false)
+      %Q[<#{url(new_scheme)}>; riaktag="#{tag}"]
+    end
+
+    def hash
+      self.to_s.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      other.is_a?(Link) && url == other.url && tag == other.tag
+    end
+
+    def to_walk_spec
+      raise t("bucket_link_conversion") if tag == "up" || key.nil?
+      WalkSpec.new(:bucket => bucket, :tag => tag)
+    end
+  end
+end