riak-client 1.4.5 → 2.0.0.rc1

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

@@ -0,0 +1,222 @@
+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
+          }.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

data/lib/riak/client/beefcake/footer

@@ -0,0 +1,4 @@
+
+    end
+  end
+end

data/lib/riak/client/beefcake/header

@@ -0,0 +1,6 @@
+require 'beefcake'
+
+module Riak
+  class Client
+    # @private
+    class BeefcakeProtobuffsBackend

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

@@ -33,12 +33,41 @@ module Riak
         :SearchQueryResp => 28,
         :ResetBucketReq => 29,
         :ResetBucketResp => 30,
+
+        # bucket types
+        :GetBucketTypeReq => 31,
+        :SetBucketTypeReq => 32,
+        :ResetBucketTypeReq => 33,
+
+        # riak cs
         :CSBucketReq => 40,
         :CSBucketResp => 41,
+
+        # 1.4 counters
         :CounterUpdateReq => 50,
         :CounterUpdateResp => 51,
         :CounterGetReq => 52,
         :CounterGetResp => 53,
+
+        # yokozuna
+        :YokozunaIndexGetReq => 54,
+        :YokozunaIndexGetResp => 55,
+        :YokozunaIndexPutReq => 56,
+        :YokozunaIndexDeleteReq => 57,
+        :YokozunaSchemaGetReq => 58,
+        :YokozunaSchemaGetResp => 59,
+        :YokozunaSchemaPutReq => 60,
+
+        # riak 2 CRDT
+        :DtFetchReq => 80,
+        :DtFetchResp => 81,
+        :DtUpdateReq => 82,
+        :DtUpdateResp => 83,
+
+        # internal
+        :AuthReq => 253,
+        :AuthResp => 254,
+        :StartTls => 255
       }
 
       CODE_TO_MESSAGE = MESSAGE_TO_CODE.invert

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

@@ -0,0 +1,61 @@
+module Riak
+  class Client
+    # @private
+    class BeefcakeProtobuffsBackend
+      class RpbIndexReq
+        module IndexQueryType
+          EQ = 0
+          RANGE = 1
+        end
+      end
+
+      class RpbBucketProps
+        def clean_hook(newval)
+          if newval.is_a? Array
+            return newval.map{|v| clean_hook v}
+          end
+
+          newval = newval.symbolize_keys if newval.is_a? Hash
+          if newval.is_a?(Hash) && newval[:module] && newval[:function]
+            modfun = RpbModFun.new newval
+            hook = RpbCommitHook.new modfun: modfun
+            newval = hook
+          elsif newval.is_a?(Hash) && newval[:name]
+            hook = RpbCommitHook.new newval
+            newval = hook
+          elsif newval.is_a? String
+            hook = RpbCommitHook.new name: newval
+            newval = hook
+          end
+
+          return newval
+        end
+
+        # "repeated" elements with zero items are indistinguishable
+        # from a nil, so we have to manage has_precommit/has_postcommit
+        # flags.
+        def precommit=(newval)
+          newval = clean_hook newval
+          @precommit = newval
+          @has_precommit = !!newval
+        end
+
+        def has_precommit=(newval)
+          @has_precommit = newval
+          @precommit ||= [] if newval
+        end
+
+        def postcommit=(newval)
+          newval = clean_hook newval
+          @postcommit = newval
+          @has_postcommit = !!newval
+        end
+
+        def has_postcommit=(newval)
+          @has_postcommit = newval
+          @postcommit ||= [] if newval
+        end
+      end
+    end
+  end
+end

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

@@ -4,377 +4,739 @@ module Riak
   class Client
     # @private
     class BeefcakeProtobuffsBackend
-      # Embedded messages
-      class RpbPair
-        include Beefcake::Message
-        required :key,   :bytes, 1
-        optional :value, :bytes, 2
-      end
-
-      # module-function pair for commit hooks and other properties that take
-      # functions
-      class RpbModFun
-        include Beefcake::Message
-
-        required :module,   :bytes, 1
-        required :function, :bytes, 2
-      end
-
-      class RpbCommitHook
-        include Beefcake::Message
-
-        optional :modfun, RpbModFun, 1
-        optional :name,   :bytes,    2
-      end
-
-      class RpbBucketProps
-        include Beefcake::Message
-
-        # riak_core_app
-        optional :n_val,           :uint32,       1
-        optional :allow_mult,      :bool,         2
-        optional :last_write_wins, :bool,         3
-
-        # riak_core values with special handling, see below
-        repeated :precommit,       RpbCommitHook, 4
-        optional :has_precommit,   :bool,         5, :default => false
-        repeated :postcommit,      RpbCommitHook, 6
-        optional :has_postcommit,  :bool,         7, :default => false
-
-        optional :chash_keyfun,    RpbModFun,     8
-
-        # riak_kv_app
-        optional :linkfun,         RpbModFun,     9
-        optional :old_vclock,      :uint32,       10
-        optional :young_vclock,    :uint32,       11
-        optional :big_vclock,      :uint32,       12
-        optional :small_vclock,    :uint32,       13
-        optional :pr,              :uint32,       14
-        optional :r,               :uint32,       15
-        optional :w,               :uint32,       16
-        optional :pw,              :uint32,       17
-        optional :dw,              :uint32,       18
-        optional :rw,              :uint32,       19
-        optional :basic_quorum,    :bool,         20
-        optional :notfound_ok,     :bool,         21
-
-        # riak_kv_multi_backend
-        optional :backend,         :bytes,        22
-
-        # riak_search bucket fixup
-        optional :search,          :bool,         23
-
-        module RpbReplMode
-          FALSE = 0
-          REALTIME = 1
-          FULLSYNC = 2
-          TRUE = 3
-        end
-
-        optional :repl,            RpbReplMode,   24
-
-        # "repeated" elements with zero items are indistinguishable
-        # from a nil, so we have to manage has_precommit/has_postcommit
-        # flags.
-        def precommit=(newval)
-          @precommit = newval
-          @has_precommit = !!newval 
-        end
-
-        def has_precommit=(newval)
-          @has_precommit = newval
-          @precommit ||= [] if newval
-        end
-
-        def postcommit=(newval)
-          @postcommit = newval
-          @has_postcommit = !!newval 
-        end
-
-        def has_postcommit=(newval)
-          @has_postcommit = newval
-          @postcommit ||= [] if newval
-        end
-      end
-
-      class RpbLink
-        include Beefcake::Message
-        optional :bucket, :bytes, 1
-        optional :key,    :bytes, 2
-        optional :tag,    :bytes, 3
-      end
-
-      class RpbContent
-        include Beefcake::Message
-        required :value,            :bytes,  1
-        optional :content_type,     :bytes,  2
-        optional :charset,          :bytes,  3
-        optional :content_encoding, :bytes,  4
-        optional :vtag,             :bytes,  5
-        repeated :links,            RpbLink, 6
-        optional :last_mod,         :uint32, 7
-        optional :last_mod_usecs,   :uint32, 8
-        repeated :usermeta,         RpbPair, 9
-        repeated :indexes,          RpbPair, 10
-      end
-
-      # Primary messages
-      class RpbErrorResp
-        include Beefcake::Message
-        required :errmsg,  :bytes,  1
-        required :errcode, :uint32, 2
-      end
-
-      class RpbGetClientIdResp
-        include Beefcake::Message
-        required :client_id, :bytes, 1
-      end
-
-      class RpbSetClientIdReq
-        include Beefcake::Message
-        required :client_id, :bytes, 1
-      end
-
-      class RpbGetServerInfoResp
-        include Beefcake::Message
-        optional :node,           :bytes, 1
-        optional :server_version, :bytes, 2
-      end
-
-      class RpbGetReq
-        include Beefcake::Message
-        required :bucket,        :bytes,  1
-        required :key,           :bytes,  2
-        optional :r,             :uint32, 3
-        optional :pr,            :uint32, 4
-        optional :basic_quorum,  :bool,   5
-        optional :notfound_ok,   :bool,   6
-        optional :if_modified,   :bytes,  7
-        optional :head,          :bool,   8
-        optional :deletedvclock, :bool,   9
-        optional :timeout,       :uint32, 10
-        optional :sloppy_quorum, :bool,   11
-        optional :n_val,         :uint32, 12
-      end
-
-      class RpbGetResp
-        include Beefcake::Message
-        repeated :content,   RpbContent, 1
-        optional :vclock,    :bytes,     2
-        optional :unchanged, :bool,      3
-      end
-
-      class RpbPutReq
-        include Beefcake::Message
-        required :bucket,          :bytes,     1
-        optional :key,             :bytes,     2
-        optional :vclock,          :bytes,     3
-        required :content,         RpbContent, 4
-        optional :w,               :uint32,    5
-        optional :dw,              :uint32,    6
-        optional :returnbody,      :bool,      7
-        optional :pw,              :uint32,    8
-        optional :if_not_modified, :bool,      9
-        optional :if_none_match,   :bool,      10
-        optional :return_head,     :bool,      11
-        optional :timeout,         :uint32,    12
-        optional :asis,            :bool,      13
-        optional :sloppy_quorum,   :bool,      14
-        optional :n_val,           :uint32,    15
-      end
-
-      class RpbPutResp
-        include Beefcake::Message
-        repeated :content, RpbContent, 1
-        optional :vclock,  :bytes,     2
-        optional :key,     :bytes,     3
-      end
-
-      class RpbDelReq
-        include Beefcake::Message
-        required :bucket,        :bytes,  1
-        required :key,           :bytes,  2
-        optional :rw,            :uint32, 3
-        optional :vclock,        :bytes,  4
-        optional :r,             :uint32, 5
-        optional :w,             :uint32, 6
-        optional :pr,            :uint32, 7
-        optional :pw,            :uint32, 8
-        optional :dw,            :uint32, 9
-        optional :timeout,       :uint32, 10
-        optional :sloppy_quorum, :bool,   11
-        optional :n_val,         :uint32, 12
-      end
-
-      class RpbListBucketsReq
-        include Beefcake::Message
-        optional :timeout, :uint32, 1
-        optional :stream, :bool, 2
-      end
-
-      class RpbListBucketsResp
-        include Beefcake::Message
-        repeated :buckets, :bytes, 1
-        optional :done, :bool, 2
-      end
-
-      class RpbListKeysReq
-        include Beefcake::Message
-        required :bucket, :bytes, 1
-        optional :timeout, :uint32, 2
-      end
-
-      class RpbListKeysResp
-        include Beefcake::Message
-        repeated :keys, :bytes, 1
-        optional :done, :bool,  2
-      end
-
-      class RpbGetBucketReq
-        include Beefcake::Message
-        required :bucket, :bytes, 1
-      end
-
-      class RpbGetBucketResp
-        include Beefcake::Message
-        required :props, RpbBucketProps, 1
-      end
-
-      class RpbSetBucketReq
-        include Beefcake::Message
-        required :bucket, :bytes,         1
-        required :props,  RpbBucketProps, 2
-      end
-
-      class RpbMapRedReq
-        include Beefcake::Message
-        required :request,      :bytes, 1
-        required :content_type, :bytes, 2
-      end
-
-      class RpbMapRedResp
-        include Beefcake::Message
-        optional :phase,    :uint32, 1
-        optional :response, :bytes,  2
-        optional :done,     :bool,   3
-      end
-
-      class RpbIndexReq
-        include Beefcake::Message
-        module IndexQueryType
-          EQ = 0
-          RANGE = 1
-        end
-
-        required :bucket,       :bytes,         1
-        required :index,        :bytes,         2
-        required :qtype,        IndexQueryType, 3
-        optional :key,          :bytes,         4
-        optional :range_min,    :bytes,         5
-        optional :range_max,    :bytes,         6
-        optional :return_terms, :bool,          7
-        optional :stream,       :bool,          8
-        optional :max_results,  :uint32,        9
-        optional :continuation, :bytes,         10
-        optional :timeout,      :uint32,        11
-      end
-
-      class RpbIndexResp
-        include Beefcake::Message
-        repeated :keys,         :bytes,  1
-        repeated :results,      RpbPair, 2
-        optional :continuation, :bytes,  3
-        optional :done,         :bool,   4
-      end
-
-      class RpbSearchDoc
-        include Beefcake::Message
-        # We have to name this differently than the .proto file does
-        # because Beefcake uses 'fields' as an instance method.
-        repeated :properties, RpbPair, 1
-      end
-
-      class RpbSearchQueryReq
-        include Beefcake::Message
-        required :q,       :bytes,  1
-        required :index,   :bytes,  2
-        optional :rows,    :uint32, 3
-        optional :start,   :uint32, 4
-        optional :sort,    :bytes,  5
-        optional :filter,  :bytes,  6
-        optional :df,      :bytes,  7
-        optional :op,      :bytes,  8
-        repeated :fl,      :bytes,  9
-        optional :presort, :bytes, 10
-      end
-
-      class RpbSearchQueryResp
-        include Beefcake::Message
-        repeated :docs, RpbSearchDoc, 1, :default => []
-        optional :max_score, :float,  2
-        optional :num_found, :uint32, 3
-      end
-
-      class RpbResetBucketReq
-        include Beefcake::Message
-        required :bucket, :bytes, 1
-      end
-
-      class RpbCSBucketReq
-        include Beefcake::Message
-        required :bucket,       :bytes,  1
-        required :start_key,    :bytes,  2
-        optional :end_key,      :bytes,  3
-        optional :start_incl,   :bool,   4, default: true
-        optional :end_incl,     :bool,   5, default: false
-        optional :continuation, :bytes,  6
-        optional :max_results,  :uint32, 7
-        optional :timeout,      :uint32, 8
-      end
-      
-      class RpbIndexObject
-        include Beefcake::Message
-        required :key,    :bytes,     1
-        required :object, RpbGetResp, 2
-      end
-
-      class RpbCSBucketResp
-        include Beefcake::Message
-        repeated :objects,      RpbIndexObject, 1
-        optional :continuation, :bytes,         2
-        optional :done,         :bool,          3
-      end
-
-      class RpbCounterUpdateReq
-        include Beefcake::Message
-        required :bucket,      :bytes,  1
-        required :key,         :bytes,  2
-        required :amount,      :sint64, 3
-        optional :w,           :uint32, 4
-        optional :dw,          :uint32, 5
-        optional :pw,          :uint32, 6
-        optional :returnvalue, :bool,   7
-      end
-
-      class RpbCounterUpdateResp
-        include Beefcake::Message
-        optional :value, :sint64, 1
-      end
-
-      class RpbCounterGetReq
-        include Beefcake::Message
-        required :bucket,       :bytes,  1
-        required :key,          :bytes,  2
-        optional :r,            :uint32, 3
-        optional :pr,           :uint32, 4
-        optional :basic_quorum, :bool,   5
-        optional :notfound_ok,  :bool,   6
-      end
-
-      class RpbCounterGetResp
-        include Beefcake::Message
-        optional :value, :sint64, 1
-      end
+## Generated from riak.proto for 
+require "beefcake"
+
+
+class RpbErrorResp
+  include Beefcake::Message
+end
+
+class RpbGetServerInfoResp
+  include Beefcake::Message
+end
+
+class RpbPair
+  include Beefcake::Message
+end
+
+class RpbGetBucketReq
+  include Beefcake::Message
+end
+
+class RpbGetBucketResp
+  include Beefcake::Message
+end
+
+class RpbSetBucketReq
+  include Beefcake::Message
+end
+
+class RpbResetBucketReq
+  include Beefcake::Message
+end
+
+class RpbGetBucketTypeReq
+  include Beefcake::Message
+end
+
+class RpbSetBucketTypeReq
+  include Beefcake::Message
+end
+
+class RpbModFun
+  include Beefcake::Message
+end
+
+class RpbCommitHook
+  include Beefcake::Message
+end
+
+class RpbBucketProps
+  include Beefcake::Message
+
+  module RpbReplMode
+    FALSE = 0
+    REALTIME = 1
+    FULLSYNC = 2
+    TRUE = 3
+  end
+end
+
+class RpbAuthReq
+  include Beefcake::Message
+end
+
+class RpbErrorResp
+  required :errmsg, :bytes, 1
+  required :errcode, :uint32, 2
+end
+
+class RpbGetServerInfoResp
+  optional :node, :bytes, 1
+  optional :server_version, :bytes, 2
+end
+
+class RpbPair
+  required :key, :bytes, 1
+  optional :value, :bytes, 2
+end
+
+class RpbGetBucketReq
+  required :bucket, :bytes, 1
+  optional :type, :bytes, 2
+end
+
+class RpbGetBucketResp
+  required :props, RpbBucketProps, 1
+end
+
+class RpbSetBucketReq
+  required :bucket, :bytes, 1
+  required :props, RpbBucketProps, 2
+  optional :type, :bytes, 3
+end
+
+class RpbResetBucketReq
+  required :bucket, :bytes, 1
+  optional :type, :bytes, 2
+end
+
+class RpbGetBucketTypeReq
+  required :type, :bytes, 1
+end
+
+class RpbSetBucketTypeReq
+  required :type, :bytes, 1
+  required :props, RpbBucketProps, 2
+end
+
+class RpbModFun
+  required :module, :bytes, 1
+  required :function, :bytes, 2
+end
+
+class RpbCommitHook
+  optional :modfun, RpbModFun, 1
+  optional :name, :bytes, 2
+end
+
+class RpbBucketProps
+  optional :n_val, :uint32, 1
+  optional :allow_mult, :bool, 2
+  optional :last_write_wins, :bool, 3
+  repeated :precommit, RpbCommitHook, 4
+  optional :has_precommit, :bool, 5, :default => false
+  repeated :postcommit, RpbCommitHook, 6
+  optional :has_postcommit, :bool, 7, :default => false
+  optional :chash_keyfun, RpbModFun, 8
+  optional :linkfun, RpbModFun, 9
+  optional :old_vclock, :uint32, 10
+  optional :young_vclock, :uint32, 11
+  optional :big_vclock, :uint32, 12
+  optional :small_vclock, :uint32, 13
+  optional :pr, :uint32, 14
+  optional :r, :uint32, 15
+  optional :w, :uint32, 16
+  optional :pw, :uint32, 17
+  optional :dw, :uint32, 18
+  optional :rw, :uint32, 19
+  optional :basic_quorum, :bool, 20
+  optional :notfound_ok, :bool, 21
+  optional :backend, :bytes, 22
+  optional :search, :bool, 23
+  optional :repl, RpbBucketProps::RpbReplMode, 24
+  optional :search_index, :bytes, 25
+  optional :datatype, :bytes, 26
+  optional :consistent, :bool, 27
+end
+
+class RpbAuthReq
+  required :user, :bytes, 1
+  required :password, :bytes, 2
+end
+## Generated from riak_kv.proto for 
+require "beefcake"
+
+
+class RpbGetClientIdResp
+  include Beefcake::Message
+end
+
+class RpbSetClientIdReq
+  include Beefcake::Message
+end
+
+class RpbGetReq
+  include Beefcake::Message
+end
+
+class RpbGetResp
+  include Beefcake::Message
+end
+
+class RpbPutReq
+  include Beefcake::Message
+end
+
+class RpbPutResp
+  include Beefcake::Message
+end
+
+class RpbDelReq
+  include Beefcake::Message
+end
+
+class RpbListBucketsReq
+  include Beefcake::Message
+end
+
+class RpbListBucketsResp
+  include Beefcake::Message
+end
+
+class RpbListKeysReq
+  include Beefcake::Message
+end
+
+class RpbListKeysResp
+  include Beefcake::Message
+end
+
+class RpbMapRedReq
+  include Beefcake::Message
+end
+
+class RpbMapRedResp
+  include Beefcake::Message
+end
+
+class RpbIndexReq
+  include Beefcake::Message
+
+  module IndexQueryType
+    eq = 0
+    range = 1
+  end
+end
+
+class RpbIndexResp
+  include Beefcake::Message
+end
+
+class RpbCSBucketReq
+  include Beefcake::Message
+end
+
+class RpbCSBucketResp
+  include Beefcake::Message
+end
+
+class RpbIndexObject
+  include Beefcake::Message
+end
+
+class RpbContent
+  include Beefcake::Message
+end
+
+class RpbLink
+  include Beefcake::Message
+end
+
+class RpbCounterUpdateReq
+  include Beefcake::Message
+end
+
+class RpbCounterUpdateResp
+  include Beefcake::Message
+end
+
+class RpbCounterGetReq
+  include Beefcake::Message
+end
+
+class RpbCounterGetResp
+  include Beefcake::Message
+end
+
+class RpbGetClientIdResp
+  required :client_id, :bytes, 1
+end
+
+class RpbSetClientIdReq
+  required :client_id, :bytes, 1
+end
+
+class RpbGetReq
+  required :bucket, :bytes, 1
+  required :key, :bytes, 2
+  optional :r, :uint32, 3
+  optional :pr, :uint32, 4
+  optional :basic_quorum, :bool, 5
+  optional :notfound_ok, :bool, 6
+  optional :if_modified, :bytes, 7
+  optional :head, :bool, 8
+  optional :deletedvclock, :bool, 9
+  optional :timeout, :uint32, 10
+  optional :sloppy_quorum, :bool, 11
+  optional :n_val, :uint32, 12
+  optional :type, :bytes, 13
+end
+
+class RpbGetResp
+  repeated :content, RpbContent, 1
+  optional :vclock, :bytes, 2
+  optional :unchanged, :bool, 3
+end
+
+class RpbPutReq
+  required :bucket, :bytes, 1
+  optional :key, :bytes, 2
+  optional :vclock, :bytes, 3
+  required :content, RpbContent, 4
+  optional :w, :uint32, 5
+  optional :dw, :uint32, 6
+  optional :return_body, :bool, 7
+  optional :pw, :uint32, 8
+  optional :if_not_modified, :bool, 9
+  optional :if_none_match, :bool, 10
+  optional :return_head, :bool, 11
+  optional :timeout, :uint32, 12
+  optional :asis, :bool, 13
+  optional :sloppy_quorum, :bool, 14
+  optional :n_val, :uint32, 15
+  optional :type, :bytes, 16
+end
+
+class RpbPutResp
+  repeated :content, RpbContent, 1
+  optional :vclock, :bytes, 2
+  optional :key, :bytes, 3
+end
+
+class RpbDelReq
+  required :bucket, :bytes, 1
+  required :key, :bytes, 2
+  optional :rw, :uint32, 3
+  optional :vclock, :bytes, 4
+  optional :r, :uint32, 5
+  optional :w, :uint32, 6
+  optional :pr, :uint32, 7
+  optional :pw, :uint32, 8
+  optional :dw, :uint32, 9
+  optional :timeout, :uint32, 10
+  optional :sloppy_quorum, :bool, 11
+  optional :n_val, :uint32, 12
+  optional :type, :bytes, 13
+end
+
+class RpbListBucketsReq
+  optional :timeout, :uint32, 1
+  optional :stream, :bool, 2
+  optional :type, :bytes, 3
+end
+
+class RpbListBucketsResp
+  repeated :buckets, :bytes, 1
+  optional :done, :bool, 2
+end
+
+class RpbListKeysReq
+  required :bucket, :bytes, 1
+  optional :timeout, :uint32, 2
+  optional :type, :bytes, 3
+end
+
+class RpbListKeysResp
+  repeated :keys, :bytes, 1
+  optional :done, :bool, 2
+end
+
+class RpbMapRedReq
+  required :request, :bytes, 1
+  required :content_type, :bytes, 2
+end
+
+class RpbMapRedResp
+  optional :phase, :uint32, 1
+  optional :response, :bytes, 2
+  optional :done, :bool, 3
+end
+
+class RpbIndexReq
+  required :bucket, :bytes, 1
+  required :index, :bytes, 2
+  required :qtype, RpbIndexReq::IndexQueryType, 3
+  optional :key, :bytes, 4
+  optional :range_min, :bytes, 5
+  optional :range_max, :bytes, 6
+  optional :return_terms, :bool, 7
+  optional :stream, :bool, 8
+  optional :max_results, :uint32, 9
+  optional :continuation, :bytes, 10
+  optional :timeout, :uint32, 11
+  optional :type, :bytes, 12
+  optional :term_regex, :bytes, 13
+  optional :pagination_sort, :bool, 14
+end
+
+class RpbIndexResp
+  repeated :keys, :bytes, 1
+  repeated :results, RpbPair, 2
+  optional :continuation, :bytes, 3
+  optional :done, :bool, 4
+end
+
+class RpbCSBucketReq
+  required :bucket, :bytes, 1
+  required :start_key, :bytes, 2
+  optional :end_key, :bytes, 3
+  optional :start_incl, :bool, 4, :default => true
+  optional :end_incl, :bool, 5, :default => false
+  optional :continuation, :bytes, 6
+  optional :max_results, :uint32, 7
+  optional :timeout, :uint32, 8
+  optional :type, :bytes, 9
+end
+
+class RpbCSBucketResp
+  repeated :objects, RpbIndexObject, 1
+  optional :continuation, :bytes, 2
+  optional :done, :bool, 3
+end
+
+class RpbIndexObject
+  required :key, :bytes, 1
+  required :object, RpbGetResp, 2
+end
+
+class RpbContent
+  required :value, :bytes, 1
+  optional :content_type, :bytes, 2
+  optional :charset, :bytes, 3
+  optional :content_encoding, :bytes, 4
+  optional :vtag, :bytes, 5
+  repeated :links, RpbLink, 6
+  optional :last_mod, :uint32, 7
+  optional :last_mod_usecs, :uint32, 8
+  repeated :usermeta, RpbPair, 9
+  repeated :indexes, RpbPair, 10
+  optional :deleted, :bool, 11
+end
+
+class RpbLink
+  optional :bucket, :bytes, 1
+  optional :key, :bytes, 2
+  optional :tag, :bytes, 3
+end
+
+class RpbCounterUpdateReq
+  required :bucket, :bytes, 1
+  required :key, :bytes, 2
+  required :amount, :sint64, 3
+  optional :w, :uint32, 4
+  optional :dw, :uint32, 5
+  optional :pw, :uint32, 6
+  optional :returnvalue, :bool, 7
+end
+
+class RpbCounterUpdateResp
+  optional :value, :sint64, 1
+end
+
+class RpbCounterGetReq
+  required :bucket, :bytes, 1
+  required :key, :bytes, 2
+  optional :r, :uint32, 3
+  optional :pr, :uint32, 4
+  optional :basic_quorum, :bool, 5
+  optional :notfound_ok, :bool, 6
+end
+
+class RpbCounterGetResp
+  optional :value, :sint64, 1
+end
+## Generated from riak_search.proto for 
+require "beefcake"
+
+
+class RpbSearchDoc
+  include Beefcake::Message
+end
+
+class RpbSearchQueryReq
+  include Beefcake::Message
+end
+
+class RpbSearchQueryResp
+  include Beefcake::Message
+end
+
+class RpbSearchDoc
+  repeated :fields, RpbPair, 1
+end
+
+class RpbSearchQueryReq
+  required :q, :bytes, 1
+  required :index, :bytes, 2
+  optional :rows, :uint32, 3
+  optional :start, :uint32, 4
+  optional :sort, :bytes, 5
+  optional :filter, :bytes, 6
+  optional :df, :bytes, 7
+  optional :op, :bytes, 8
+  repeated :fl, :bytes, 9
+  optional :presort, :bytes, 10
+end
+
+class RpbSearchQueryResp
+  repeated :docs, RpbSearchDoc, 1
+  optional :max_score, :float, 2
+  optional :num_found, :uint32, 3
+end
+## Generated from riak_yokozuna.proto for 
+require "beefcake"
+
+
+class RpbYokozunaIndex
+  include Beefcake::Message
+end
+
+class RpbYokozunaIndexGetReq
+  include Beefcake::Message
+end
+
+class RpbYokozunaIndexGetResp
+  include Beefcake::Message
+end
+
+class RpbYokozunaIndexPutReq
+  include Beefcake::Message
+end
+
+class RpbYokozunaIndexDeleteReq
+  include Beefcake::Message
+end
+
+class RpbYokozunaSchema
+  include Beefcake::Message
+end
+
+class RpbYokozunaSchemaPutReq
+  include Beefcake::Message
+end
+
+class RpbYokozunaSchemaGetReq
+  include Beefcake::Message
+end
+
+class RpbYokozunaSchemaGetResp
+  include Beefcake::Message
+end
+
+class RpbYokozunaIndex
+  required :name, :bytes, 1
+  optional :schema, :bytes, 2
+  optional :n_val, :uint32, 3
+end
+
+class RpbYokozunaIndexGetReq
+  optional :name, :bytes, 1
+end
+
+class RpbYokozunaIndexGetResp
+  repeated :index, RpbYokozunaIndex, 1
+end
+
+class RpbYokozunaIndexPutReq
+  required :index, RpbYokozunaIndex, 1
+end
+
+class RpbYokozunaIndexDeleteReq
+  required :name, :bytes, 1
+end
+
+class RpbYokozunaSchema
+  required :name, :bytes, 1
+  optional :content, :bytes, 2
+end
+
+class RpbYokozunaSchemaPutReq
+  required :schema, RpbYokozunaSchema, 1
+end
+
+class RpbYokozunaSchemaGetReq
+  required :name, :bytes, 1
+end
+
+class RpbYokozunaSchemaGetResp
+  required :schema, RpbYokozunaSchema, 1
+end
+## Generated from riak_dt.proto for 
+require "beefcake"
+
+
+class MapField
+  include Beefcake::Message
+
+  module MapFieldType
+    COUNTER = 1
+    SET = 2
+    REGISTER = 3
+    FLAG = 4
+    MAP = 5
+  end
+end
+
+class MapEntry
+  include Beefcake::Message
+end
+
+class DtFetchReq
+  include Beefcake::Message
+end
+
+class DtValue
+  include Beefcake::Message
+end
+
+class DtFetchResp
+  include Beefcake::Message
+
+  module DataType
+    COUNTER = 1
+    SET = 2
+    MAP = 3
+  end
+end
+
+class CounterOp
+  include Beefcake::Message
+end
+
+class SetOp
+  include Beefcake::Message
+end
+
+class MapUpdate
+  include Beefcake::Message
+
+  module FlagOp
+    ENABLE = 1
+    DISABLE = 2
+  end
+end
+
+class MapOp
+  include Beefcake::Message
+end
+
+class DtOp
+  include Beefcake::Message
+end
+
+class DtUpdateReq
+  include Beefcake::Message
+end
+
+class DtUpdateResp
+  include Beefcake::Message
+end
+
+class MapField
+  required :name, :bytes, 1
+  required :type, MapField::MapFieldType, 2
+end
+
+class MapEntry
+  required :field, MapField, 1
+  optional :counter_value, :sint64, 2
+  repeated :set_value, :bytes, 3
+  optional :register_value, :bytes, 4
+  optional :flag_value, :bool, 5
+  repeated :map_value, MapEntry, 6
+end
+
+class DtFetchReq
+  required :bucket, :bytes, 1
+  required :key, :bytes, 2
+  required :type, :bytes, 3
+  optional :r, :uint32, 4
+  optional :pr, :uint32, 5
+  optional :basic_quorum, :bool, 6
+  optional :notfound_ok, :bool, 7
+  optional :timeout, :uint32, 8
+  optional :sloppy_quorum, :bool, 9
+  optional :n_val, :uint32, 10
+  optional :include_context, :bool, 11, :default => true
+end
+
+class DtValue
+  optional :counter_value, :sint64, 1
+  repeated :set_value, :bytes, 2
+  repeated :map_value, MapEntry, 3
+end
+
+class DtFetchResp
+  optional :context, :bytes, 1
+  required :type, DtFetchResp::DataType, 2
+  optional :value, DtValue, 3
+end
+
+class CounterOp
+  optional :increment, :sint64, 1
+end
+
+class SetOp
+  repeated :adds, :bytes, 1
+  repeated :removes, :bytes, 2
+end
+
+class MapUpdate
+  required :field, MapField, 1
+  optional :counter_op, CounterOp, 2
+  optional :set_op, SetOp, 3
+  optional :register_op, :bytes, 4
+  optional :flag_op, MapUpdate::FlagOp, 5
+  optional :map_op, MapOp, 6
+end
+
+class MapOp
+  repeated :removes, MapField, 1
+  repeated :updates, MapUpdate, 2
+end
+
+class DtOp
+  optional :counter_op, CounterOp, 1
+  optional :set_op, SetOp, 2
+  optional :map_op, MapOp, 3
+end
+
+class DtUpdateReq
+  required :bucket, :bytes, 1
+  optional :key, :bytes, 2
+  required :type, :bytes, 3
+  optional :context, :bytes, 4
+  required :op, DtOp, 5
+  optional :w, :uint32, 6
+  optional :dw, :uint32, 7
+  optional :pw, :uint32, 8
+  optional :return_body, :bool, 9, :default => false
+  optional :timeout, :uint32, 10
+  optional :sloppy_quorum, :bool, 11
+  optional :n_val, :uint32, 12
+  optional :include_context, :bool, 13, :default => true
+end
+
+class DtUpdateResp
+  optional :key, :bytes, 1
+  optional :context, :bytes, 2
+  optional :counter_value, :sint64, 3
+  repeated :set_value, :bytes, 4
+  repeated :map_value, MapEntry, 5
+end
+
     end
   end
 end