riak-client 1.4.5 → 2.0.0.rc1

data/lib/riak/crdt/operation.rb

@@ -0,0 +1,19 @@
+module Riak
+  module Crdt
+    # @api private
+    module Operation
+      class Update
+        attr_accessor :parent
+        attr_accessor :name
+        attr_accessor :type
+        attr_accessor :value
+      end
+
+      class Delete
+        attr_accessor :parent
+        attr_accessor :name
+        attr_accessor :type
+      end
+    end
+  end
+end

data/lib/riak/crdt/set.rb

@@ -0,0 +1,156 @@
+module Riak
+  module Crdt
+
+    # A distributed set containing strings, using the Riak 2 Data Types feature.
+    #
+    # Uses the Ruby standard library `::Set` frequently, so the full class names will
+    # be used frequently.
+    class Set < Base
+      
+      # Create a set instance. If not provided, the default bucket type from
+      # {Riak::Crdt} will be used.
+      #
+      # @param bucket [Bucket] the {Riak::Bucket} for this set
+      # @param [String, nil] key The name of the set. A nil key makes
+      #        Riak assign a key.
+      # @param [String] bucket_type The optional bucket type for this set.
+      #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:set]`.
+      # @param options [Hash]
+      def initialize(bucket, key, bucket_type=nil, options={})
+        super(bucket, key, bucket_type || DEFAULT_BUCKET_TYPES[:set], options)
+      end
+
+      # Yields a `BatchSet` to proxy multiple set operations into a single
+      # Riak update. The `BatchSet` has the same methods as this 
+      # {Riak::Crdt::Set}.
+      #
+      # @yieldparam batch_set [BatchSet] collects set operations
+      def vivify(value)
+        value.each(&:freeze)
+        @members = ::Set.new(value)
+        @members.freeze
+      end
+
+      def batch
+        batcher = BatchSet.new self
+
+        yield batcher
+        
+        operate batcher.operations
+      end
+
+      # Gets the current set members from Riak if necessary, and return the
+      # stdlib `::Set` of them.
+      #
+      # @return [::Set] a Ruby standard library {::Set} of the members
+      #                 of this {Riak::Crdt::Set}
+      def members
+        reload if dirty?
+        @members
+      end
+
+      alias :value :members
+      
+      # Cast this {Riak::Crdt::Set} to a Ruby {Array}.
+      #
+      # @return [Array] array of set members
+      def to_a
+        members.to_a
+      end
+
+      # Check to see if this structure has any members.
+      #
+      # @return [Boolean] if the structure is empty
+      def empty?
+        members.empty?
+      end
+      
+      # Check to see if a given string is present in this data structure.
+      #
+      # @param [String] candidate string to check for inclusion in this structure
+      # @return [Boolean] if the structure includes
+      def include?(candidate)
+        members.include?(candidate)
+      end
+
+      # Add a {String} to the {Riak::Crdt::Set}
+      #
+      # @param [String] element the element to add to the set
+      # @param [Hash] options
+      def add(element, options={})
+        operate operation(:add, element), options
+      end
+
+      # Remove a {String} from the {Riak::Crdt::Set}
+      #
+      # @param [String] element to remove from the set
+      # @param [Hash] options
+      def remove(element, options={})
+        raise CrdtError::SetRemovalWithoutContextError unless context?
+        operate operation(:remove, element), options
+      end
+
+      alias :delete :remove
+      
+      private
+      def vivify(value)
+        @members = value
+      end
+
+      def operation(direction, element)
+        Operation::Update.new.tap do |op|
+          op.type = :set
+          op.value = { direction => element }
+        end
+      end
+
+      class BatchSet
+        def initialize(base)
+          @base = base
+          @adds = ::Set.new
+          @removes = ::Set.new
+        end
+        
+        def add(element)
+          @adds.add element
+        end
+
+        def remove(element)
+          raise CrdtError::SetRemovalWithoutContextError.new unless context?
+          @removes.add element
+        end
+
+        alias :delete :remove
+
+        def include?(element)
+          members.include? element
+        end
+
+        def empty?
+          members.empty?
+        end
+
+        def context?
+          @base.context?
+        end
+
+        def to_a
+          members.to_a
+        end
+
+        def members
+          (@base + @adds).subtract @removes
+        end
+
+        alias :value :members
+
+        def operations
+          Operation::Update.new.tap do |op|
+            op.type = :set
+            op.value = {add: @adds.to_a, remove: @removes.to_a}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riak/crdt/typed_collection.rb

@@ -0,0 +1,131 @@
+module Riak
+  module Crdt
+    # A collection of elements of a given type inside a {Map}.
+    class TypedCollection
+
+      ALREADY_WRAPPED = ::Set.new [InnerCounter, InnerFlag, InnerMap]
+      NEEDS_NAME = ::Set.new [InnerCounter, InnerSet, InnerMap]
+      INITIALIZE_NIL = ::Set.new [InnerRegister]
+      
+      # @api private
+      def initialize(type, parent, contents={})
+        @type = type
+        @parent = parent
+        contents = {} if contents.nil?
+        stringified_contents = contents.stringify_keys
+        @contents = stringified_contents.keys.inject(Hash.new) do |contents, key|
+          contents.tap do |c|
+            content = stringified_contents[key]
+            if ALREADY_WRAPPED.include? content.class
+              c[key] = content
+            else
+              c[key] = @type.new self, content
+            end
+            c[key].name = key if needs_name?
+          end
+        end
+      end
+
+      # @api private
+      def reparent(new_parent)
+        reparented = self.class.new(@type,
+                                    new_parent,
+                                    @contents)
+      end
+      
+      # Check if a value for a given key exists in this map.
+      #
+      # @param [String] key the key to check for
+      # @return [Boolean] if the key is inside this collection
+      def include?(key)
+        @contents.include? normalize_key(key)
+      end
+      
+      # Get the value for a given key
+      #
+      # @param [String] key the key to get the value for
+      # @return the value for the given key
+      def [](key)
+        key = normalize_key key
+        if include? key
+          candidate = @contents[key]
+          return candidate unless candidate.respond_to? :parent
+          return candidate if candidate.parent == self
+        end
+
+        return nil if initialize_nil?
+        
+        new_instance = @type.new self
+        new_instance.name = key if needs_name?
+
+        return new_instance
+      end
+
+      # Set the value for a given key. Operation of this method
+      # is only defined for {InnerCounter}, {InnerRegister}, and 
+      # {InnerFlag} types.
+      #
+      # @param [String] key the key to set a new value for
+      # @param [Boolean, String, Integer] value the value to set at the key,
+      #        or in the case of counters, the amount to increment
+      def []=(key, value)
+        key = normalize_key key
+
+        operation = @type.update value
+        operation.name = key
+
+        result = @parent.operate operation
+
+        @contents[key] = @type.new self, value
+        @contents[key].name = key if needs_name?
+        
+        result
+      end
+      
+      alias :increment :[]=
+
+      # Remove the entry from the map.
+      #
+      # @param [String] key the key to remove from the map
+      def delete(key)
+        key = normalize_key key
+        operation = @type.delete
+        operation.name = key
+
+        @parent.operate operation
+
+        @contents.delete key
+      end
+
+      # @api private
+      def operate(key, inner_operation)
+        key = normalize_key key
+        
+        inner_operation.name = key
+        
+        @parent.operate inner_operation
+      end
+      
+      
+      # Does this set have the context necessary to remove elements?
+      #
+      # @return [Boolean] if the set has a defined context
+      def context?
+        !!@parent.context?
+      end
+      
+      private
+      def normalize_key(unnormalized_key)
+        unnormalized_key.to_s
+      end
+
+      def initialize_nil?
+        INITIALIZE_NIL.include? @type
+      end
+      
+      def needs_name?
+        NEEDS_NAME.include? @type
+      end
+    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,44 @@
+require 'riak/errors/base'
+
+module Riak
+  class ConnectionError < Error
+  end
+
+  class TlsError < ConnectionError
+    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,18 @@
+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
+  end
+end

data/lib/riak/errors/failed_request.rb

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