riak-client-noenc 1.0.0

data/lib/riak/client/beefcake/bucket_properties_operator.rb

@@ -0,0 +1,178 @@
+class Riak::Client::BeefcakeProtobuffsBackend
+  def bucket_properties_operator
+    BucketPropertiesOperator.new(self)
+  end
+
+
+  class BucketPropertiesOperator
+    attr_reader :backend
+
+    QUORUMS = Riak::Client::ProtobuffsBackend::QUORUMS
+
+    def initialize(backend)
+      @backend = backend
+    end
+
+    def get(bucket, options = {})
+      response = backend.protocol do |p|
+        p.write :GetBucketReq, get_request(bucket, options)
+        p.expect :GetBucketResp, RpbGetBucketResp
+      end
+
+      properties = response.props.to_hash.stringify_keys
+
+      return rubyfy(properties)
+    end
+
+    def put(bucket, props = {}, options = {})
+      properties = riakify props
+
+      request = put_request bucket, properties, options
+
+      backend.protocol do |p|
+        p.write :SetBucketReq, request
+        p.expect :SetBucketResp
+      end
+    end
+
+    private
+    def rubyfy(received_properties)
+      props = received_properties.dup
+
+      rubyfy_quorums(props)
+      rubyfy_hooks(props)
+      rubyfy_modfuns(props)
+
+      return props
+    end
+
+    def riakify(requested_properties)
+      props = requested_properties.stringify_keys
+
+      riakify_quorums(props)
+      riakify_hooks(props)
+      riakify_modfuns(props)
+      riakify_repl_mode(props)
+
+      return props
+    end
+
+    def rubyfy_quorums(props)
+      %w{r pr w pw dw rw}.each do |k|
+        next unless props[k]
+        next unless QUORUMS.values.include? props[k]
+
+        props[k] = QUORUMS.invert[props[k]]
+      end
+    end
+
+    def riakify_quorums(props)
+      %w{r pr w pw dw rw}.each do |k|
+        next unless props[k]
+        v = props[k].to_s
+        next unless QUORUMS.keys.include? v
+
+        props[k] = QUORUMS[v]
+      end
+    end
+
+    def rubyfy_hooks(props)
+      %w{precommit postcommit}.each do |k|
+        next unless props[k]
+        props[k] = props[k].map do |v|
+          next v[:name] if v[:name]
+          rubyfy_modfun(v[:modfun])
+        end
+      end
+    end
+
+    def riakify_hooks(props)
+      %w{precommit postcommit}.each do |k|
+        next unless v = props[k]
+
+        if v.is_a? Array
+          props[k] = v.map{ |e| riakify_single_hook(e) }
+        else
+          props[k] = [riakify_single_hook(v)]
+        end
+      end
+    end
+
+    def riakify_single_hook(hook)
+      message = RpbCommitHook.new
+
+      if hook.is_a? String
+        message.name = hook
+      elsif hook['name']
+        message.name = hook['name']
+      else
+        message.modfun = riakify_modfun(hook)
+      end
+      return message
+    end
+
+    def rubyfy_modfuns(props)
+      %w{chash_keyfun linkfun}.each do |k|
+        next if props[k].nil?
+        props[k] = rubyfy_modfun(props[k])
+      end
+    end
+
+    def riakify_modfuns(props)
+      %w{chash_keyfun linkfun}.each do |k|
+        next if props[k].nil?
+        props[k] = riakify_modfun(props[k])
+      end
+    end
+
+    def rubyfy_modfun(modfun)
+      {
+        'mod' => modfun[:module],
+        'fun' => modfun[:function]
+      }
+    end
+
+    def riakify_modfun(modfun)
+      m = modfun.stringify_keys
+      RpbModFun.new(module: m['mod'], function: m['fun'])
+    end
+
+    def riakify_repl_mode(props)
+      return unless props['repl'].is_a? Symbol
+
+      props['repl'] = case props['repl']
+                      when :false
+                        0
+                      when :realtime
+                        1
+                      when :fullsync
+                        2
+                      when :true
+                        3
+                      end
+    end
+
+    def name_options(bucket)
+      o = {}
+      if bucket.is_a? Riak::Bucket
+        o[:bucket] = bucket.name
+        o[:type] = bucket.type.name if bucket.needs_type?
+      else
+        o[:bucket] = bucket
+      end
+
+      return o
+    end
+
+    def get_request(bucket, options)
+      RpbGetBucketReq.new options.merge name_options(bucket)
+    end
+
+    def put_request(bucket, props, options)
+      req_options = options.merge name_options(bucket)
+      req_options[:props] = RpbBucketProps.new props.symbolize_keys
+
+      RpbSetBucketReq.new req_options
+    end
+  end
+end

data/lib/riak/client/beefcake/crdt/counter_loader.rb

@@ -0,0 +1,18 @@
+class Riak::Client::BeefcakeProtobuffsBackend
+  class CrdtLoader
+    class CounterLoader
+      def self.for_value(resp)
+        return nil unless resp.counter_value
+        new resp.counter_value
+      end
+
+      def initialize(counter_value)
+        @value = counter_value
+      end
+
+      def rubyfy
+        @value
+      end
+    end
+  end
+end

data/lib/riak/client/beefcake/crdt/map_loader.rb

@@ -0,0 +1,64 @@
+class Riak::Client::BeefcakeProtobuffsBackend
+  class CrdtLoader
+    class MapLoader
+      def self.for_value(resp)
+        return nil unless resp.map_value
+        new resp.map_value
+      end
+
+      def initialize(map_value)
+        @value = map_value
+      end
+
+      def rubyfy
+        accum = {
+          counters: {},
+          flags: {},
+          maps: {},
+          registers: {},
+          sets: {}
+        }
+
+        contents_loop @value, accum
+      end
+
+      private
+
+      def rubyfy_inner(accum, map_value)
+        destination = accum[:maps][map_value.field.name]
+        if destination.nil?
+          destination = accum[:maps][map_value.field.name] = {
+            counters: {},
+            flags: {},
+            maps: {},
+            registers: {},
+            sets: {}
+          }
+        end
+
+        contents_loop map_value.map_value, destination
+      end
+
+      def contents_loop(rolling_value, destination)
+        return destination if rolling_value.nil?
+
+        rolling_value.each do |inner|
+          case inner.field.type
+          when MapField::MapFieldType::COUNTER
+            destination[:counters][inner.field.name] = inner.counter_value
+          when MapField::MapFieldType::FLAG
+            destination[:flags][inner.field.name] = inner.flag_value
+          when MapField::MapFieldType::MAP
+            rubyfy_inner destination, inner
+          when MapField::MapFieldType::REGISTER
+            destination[:registers][inner.field.name] = inner.register_value
+          when MapField::MapFieldType::SET
+            destination[:sets][inner.field.name] = ::Set.new inner.set_value
+          end
+        end
+
+        return destination
+      end
+    end
+  end
+end

data/lib/riak/client/beefcake/crdt/set_loader.rb

@@ -0,0 +1,18 @@
+class Riak::Client::BeefcakeProtobuffsBackend
+  class CrdtLoader
+    class SetLoader
+      def self.for_value(resp)
+        return nil unless resp.set_value
+        new resp.set_value
+      end
+
+      def initialize(set_value)
+        @value = set_value
+      end
+
+      def rubyfy
+        ::Set.new @value
+      end
+    end
+  end
+end

data/lib/riak/client/beefcake/crdt_loader.rb

@@ -0,0 +1,84 @@
+require 'riak/client/beefcake/crdt/counter_loader'
+require 'riak/client/beefcake/crdt/map_loader'
+require 'riak/client/beefcake/crdt/set_loader'
+
+module Riak
+  class Client
+    class BeefcakeProtobuffsBackend
+
+      # Returns a new {CrdtLoader} for deserializing a protobuffs response full
+      # of CRDTs.
+      # @api private
+      def crdt_loader
+        return CrdtLoader.new self
+      end
+
+      # Loads, and deserializes CRDTs from protobuffs into Ruby hashes,
+      # sets, strings, and integers.
+      # @api private
+      class CrdtLoader
+        include Util::Translation
+
+        attr_reader :backend, :context
+
+        def initialize(backend)
+          @backend = backend
+        end
+
+        # Perform the protobuffs request and return a deserialized CRDT.
+        def load(bucket, key, bucket_type, options = {})
+          bucket = bucket.name if bucket.is_a? ::Riak::Bucket
+          fetch_args = options.merge(
+                                     bucket: bucket,
+                                     key: key,
+                                     type: bucket_type
+                                     )
+          request = DtFetchReq.new fetch_args
+
+          response = backend.protocol do |p|
+            p.write :DtFetchReq, request
+            p.expect :DtFetchResp, DtFetchResp
+          end
+
+          @context = response.context
+          rubyfy response
+        end
+
+        def get_loader_for_value(value)
+          return nil if value.nil?
+
+          [CounterLoader, MapLoader, SetLoader].map do |loader|
+            loader.for_value value
+          end.compact.first
+        end
+
+        private
+        # Convert the protobuffs response into low-level Ruby objects.
+        def rubyfy(response)
+          loader = get_loader_for_value response.value
+          return nil_rubyfy(response.type) if loader.nil?
+
+          return loader.rubyfy
+        end
+
+        # Sometimes a CRDT is empty, provide a sane default.
+        def nil_rubyfy(type)
+          case type
+          when DtFetchResp::DataType::COUNTER
+            0
+          when DtFetchResp::DataType::SET
+            ::Set.new
+          when DtFetchResp::DataType::MAP
+            {
+              counters: {},
+              flags: {},
+              maps: {},
+              registers: {},
+              sets: {},
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riak/client/beefcake/crdt_operator.rb

@@ -0,0 +1,223 @@
+require 'riak/errors/crdt_error'
+
+module Riak
+  class Client
+    class BeefcakeProtobuffsBackend
+
+      # Returns a new {CrdtOperator} for serializing CRDT operations into
+      # protobuffs and sending them to a Riak cluster.
+      # @api private
+      def crdt_operator
+        return CrdtOperator.new self
+      end
+
+      # Serializes and writes CRDT operations from {Riak::Crdt::Operation} members
+      # into protobuffs, and writes them to a Riak cluster.
+      # @api private
+      class CrdtOperator
+        include Util::Translation
+
+        attr_reader :backend
+
+        def initialize(backend)
+          @backend = backend
+        end
+
+        # Serializes and writes CRDT operations.
+        def operate(bucket, key, bucket_type, operation, options = {})
+          serialized = serialize(operation)
+          args = {
+            bucket: bucket,
+            key: key,
+            type: bucket_type,
+            op: serialized,
+            return_body: true,
+          }.merge options
+          request = DtUpdateReq.new args
+          begin
+            return backend.protocol do |p|
+              p.write :DtUpdateReq, request
+              p.expect :DtUpdateResp, DtUpdateResp, empty_body_acceptable: true
+            end
+          rescue ProtobuffsErrorResponse => e
+            raise unless e.message =~ /precondition/
+            raise CrdtError::PreconditionError.new e.message
+          end
+        end
+
+        # Serializes CRDT operations without writing them.
+        def serialize(operations)
+          return serialize [operations] unless operations.is_a? Enumerable
+
+          serialize_wrap operations
+        end
+
+        private
+        def serialize_wrap(operations)
+          raise ArgumentError, t('crdt.serialize_no_ops') if operations.empty?
+          ops = serialize_group operations
+
+          DtOp.new(wrap_field_for(operations) => ops)
+        end
+
+        def wrap_field_for(ops)
+          "#{ops.first.type.to_s}_op".to_sym
+        end
+
+        def serialize_group(operations)
+          case operations.first.type
+          when :counter
+            serialize_counter operations
+          when :set
+            serialize_set operations
+          when :map
+            serialize_map operations
+          else
+            raise ArgumentError, t('crdt.unknown_field', symbol: operation.type.inspect)
+          end
+        end
+
+        def inner_serialize_group(operations)
+          updates, deletes = operations.partition do |op|
+            op.value.is_a? Riak::Crdt::Operation::Update
+          end
+          serialized_updates = updates.map do |operation|
+            inner_serialize operation.value
+          end
+          serialized_deletes = deletes.map do |operation|
+            inner_serialize_delete operation.value
+          end
+
+          { updates: serialized_updates,
+            removes: serialized_deletes
+          }
+        end
+
+        def inner_serialize(operation)
+          case operation.type
+          when :counter
+            serialize_inner_counter operation
+          when :flag
+            serialize_flag operation
+          when :register
+            serialize_register operation
+          when :set
+            serialize_inner_set operation
+          when :map
+            serialize_inner_map operation
+          else
+            raise ArgumentError, t('crdt.unknown_inner_field',
+                                   symbol: operation.type.inspect)
+          end
+        end
+
+        def inner_serialize_delete(operation)
+          MapField.new(
+                       name: operation.name,
+                       type: type_symbol_to_type_enum(operation.type)
+                       )
+        end
+
+        def serialize_counter(counter_ops)
+          amount = counter_ops.inject(0){|m, o| m += o.value }
+          CounterOp.new(increment: amount)
+        end
+
+        def serialize_inner_counter(counter_op)
+          MapUpdate.new(
+                        field: MapField.new(
+                                            name: counter_op.name,
+                                            type: MapField::MapFieldType::COUNTER
+                                            ),
+                        counter_op: CounterOp.new(
+                                                  increment: counter_op.value
+                                                  )
+                        )
+        end
+
+        def serialize_flag(flag_op)
+          operation_value = flag_op.value ? MapUpdate::FlagOp::ENABLE : MapUpdate::FlagOp::DISABLE
+          MapUpdate.new(
+                        field: MapField.new(
+                                            name: flag_op.name,
+                                            type: MapField::MapFieldType::FLAG
+                                            ),
+                        flag_op: operation_value
+                        )
+        end
+
+        def serialize_register(register_op)
+          MapUpdate.new(
+                        field: MapField.new(
+                                            name: register_op.name,
+                                            type: MapField::MapFieldType::REGISTER
+                                            ),
+                        register_op: register_op.value
+                        )
+        end
+
+        def serialize_set(set_ops)
+          adds = ::Set.new
+          removes = ::Set.new
+          set_ops.each do |o|
+            adds.add [o.value[:add]] if o.value[:add]
+            removes.merge [o.value[:remove]] if o.value[:remove]
+          end
+
+          SetOp.new(
+                    adds: adds.to_a.flatten,
+                    removes: removes.to_a.flatten
+                    )
+        end
+
+        def serialize_inner_set(set_op)
+          value = set_op.value or nil
+
+          MapUpdate.new(
+                        field: MapField.new(
+                                            name: set_op.name,
+                                            type: MapField::MapFieldType::SET
+                                            ),
+                        set_op: SetOp.new(
+                                          adds: value[:add],
+                                          removes: value[:remove]
+                                          )
+                        )
+        end
+
+        def serialize_map(map_ops)
+          inner_serialized = inner_serialize_group map_ops
+
+          MapOp.new(inner_serialized)
+        end
+
+        def serialize_inner_map(map_op)
+          inner_op = map_op.value
+          if inner_op.is_a? Riak::Crdt::Operation::Delete
+            return MapUpdate.new(field: MapField.new(
+                                                     name: map_op.name,
+                                                     type: MapField::MapFieldType::MAP
+                                                     ),
+                                 map_op: MapOp.new(
+                                                   removes: inner_op.name)
+                                 )
+          end
+          inner_serialized = inner_serialize inner_op
+
+          MapUpdate.new(
+                        field: MapField.new(
+                                            name: map_op.name,
+                                            type: MapField::MapFieldType::MAP
+                                            ),
+                        map_op: MapOp.new(
+                                          updates: [inner_serialized]
+                                     ))
+        end
+
+        def type_symbol_to_type_enum(sym)
+          MapField::MapFieldType.const_get sym.to_s.upcase
+        end
+      end
+    end
+  end
+end