riak-client 2.4.0 → 2.4.1

data/lib/riak/crdt/map.rb

@@ -1,6 +1,5 @@
 module Riak
   module Crdt
-
     # A distributed map of multiple fields, such as counters, flags, registers,
     # sets, and, recursively, other maps, using the Riak 2 Data Types feature.
     #

data/lib/riak/crdt/set.rb

@@ -1,3 +1,5 @@
+require 'riak/util/string'
+
 module Riak
   module Crdt
 
@@ -6,6 +8,7 @@ module Riak
     # Uses the Ruby standard library `::Set` frequently, so the full class names will
     # be used frequently.
     class Set < Base
+      include Util::String
 
       # Create a set instance. The bucket type is determined by the first of
       # these sources:
@@ -73,7 +76,7 @@ module Riak
       # @param [String] candidate string to check for inclusion in this structure
       # @return [Boolean] if the structure includes
       def include?(candidate)
-        members.include?(candidate)
+        members.any? { |m| equal_bytes?(m, candidate) }
       end
 
       # Add a {String} to the {Riak::Crdt::Set}

data/lib/riak/crdt/typed_collection.rb

@@ -74,7 +74,7 @@ module Riak
       # @param [String] key the key to get the value for
       # @return the value for the given key
       def [](key)
-        key = normalize_key key
+        key = normalize_key(key)
         if include? key
           candidate = @contents[key]
           return candidate unless candidate.respond_to? :parent
@@ -97,7 +97,7 @@ module Riak
       # @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
+        key = normalize_key(key)
 
         operation = @type.update value
         operation.name = key
@@ -112,11 +112,15 @@ module Riak
 
       alias_method :increment, :[]=
 
+      def length
+        @contents.length
+      end
+
       # Remove the entry from the map.
       #
       # @param [String] key the key to remove from the map
       def delete(key)
-        key = normalize_key key
+        key = normalize_key(key)
         operation = @type.delete
         operation.name = key
 
@@ -127,7 +131,7 @@ module Riak
 
       # @api private
       def operate(key, inner_operation)
-        key = normalize_key key
+        key = normalize_key(key)
 
         inner_operation.name = key
 
@@ -152,7 +156,7 @@ module Riak
       private
 
       def normalize_key(unnormalized_key)
-        unnormalized_key.to_s
+        unnormalized_key.to_s.dup.force_encoding('binary')
       end
 
       def initialize_nil?

data/lib/riak/util/string.rb

@@ -0,0 +1,31 @@
+module Riak
+  module Util
+    # Methods comparing strings
+    module String
+      def equal_bytes?(a, b)
+        return true if a.nil? && b.nil?
+
+        return false unless a.respond_to?(:bytesize)
+        return false unless b.respond_to?(:bytesize)
+        return false unless a.bytesize == b.bytesize
+
+        return false unless a.respond_to?(:bytes)
+        return false unless b.respond_to?(:bytes)
+
+        b1 = a.bytes.to_a
+        b2 = b.bytes.to_a
+        i = 0
+        loop do
+          c1 = b1[i]
+          c2 = b2[i]
+          return false unless c1 == c2
+          i += 1
+          break if i > b1.length
+        end
+        true
+      end
+
+      module_function :equal_bytes?
+    end
+  end
+end

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.4.0"
+  VERSION = "2.4.1"
 end

data/riak-client.gemspec

@@ -15,19 +15,20 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9.3'
 
   # Deps
-  gem.add_development_dependency 'rspec', '~> 3.0'
-  gem.add_development_dependency 'rake', '~> 10.1'
-  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'activesupport', '~> 4.2'
+  gem.add_development_dependency 'instrumentable', '~> 1.1'
   gem.add_development_dependency 'kramdown', '~> 1.4'
+  gem.add_development_dependency 'rake', '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'rubocop', '~> 0.40.0'
   gem.add_development_dependency 'simplecov', '~> 0.10'
-  gem.add_development_dependency 'instrumentable', '~> 1.1'
-  gem.add_development_dependency 'rubocop', '~> 0.40'
+  gem.add_development_dependency 'yard', '~> 0.8'
 
-  gem.add_runtime_dependency 'i18n', '~> 0.6'
   gem.add_runtime_dependency 'beefcake', '~> 1.1'
-  gem.add_runtime_dependency 'multi_json', '~> 1.0'
-  gem.add_runtime_dependency 'innertube', '~> 1.0'
   gem.add_runtime_dependency 'cert_validator', '~> 0.0.1'
+  gem.add_runtime_dependency 'i18n', '~> 0.6'
+  gem.add_runtime_dependency 'innertube', '~> 1.0'
+  gem.add_runtime_dependency 'multi_json', '~> 1.0'
 
   # Files
 

data/spec/integration/riak/encodings/crdt_spec.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 require 'spec_helper'
 require 'riak'
+require 'riak/util/string'
 
 describe 'Encoding and CRDTs', integration: true, search_config: true do
   shared_examples 'CRDTs with weird names' do
@@ -16,6 +17,7 @@ describe 'Encoding and CRDTs', integration: true, search_config: true do
 
     it 'creates counters' do
       counter = nil
+
       expect{ counter = Riak::Crdt::Counter.new counter_bucket, random_string }.
         to_not raise_error
 
@@ -24,44 +26,61 @@ describe 'Encoding and CRDTs', integration: true, search_config: true do
       expect(value = counter.value).to be_a Numeric
 
       expect{ counter.increment }.to_not raise_error
+
       expect(counter.value).to eq value + 1
     end
 
     it 'updates registers in maps' do
       map = nil
+
+      expect(random_string.encoding.name).to eq expected_encoding
+
       expect{ map = Riak::Crdt::Map.new map_bucket, random_string }.
         to_not raise_error
 
       expect(map).to be_a Riak::Crdt::Map
 
       expect(map.registers[random_string]).to be_nil
+
       expect{ map.registers[random_string] = random_string }.
         to_not raise_error
 
-      expect(map.registers[random_string]).to eq random_string
+      expect(map.registers.length).to eq 1
+
+      expect(map.registers[random_string]).to_not be_nil
+
+      expect(Riak::Util::String.equal_bytes?(map.registers[random_string], random_string)).to be
+
+      expect(random_string.encoding.name).to eq expected_encoding
     end
 
     it 'updates sets' do
       set = nil
+
+      expect(random_string.encoding.name).to eq expected_encoding
+
       expect{ set = Riak::Crdt::Set.new set_bucket, random_string }.
         to_not raise_error
 
       expect(set).to be_a Riak::Crdt::Set
 
-      expect(set.members).to_not include random_string
+      expect(set.include?(random_string)).to_not be
 
       set.add random_string
 
-      expect(set.members).to include random_string
+      expect(set.include?(random_string)).to be
 
       set.remove random_string
 
-      expect(set.members).to_not include random_string
+      expect(set.include?(random_string)).to_not be
+
+      expect(random_string.encoding.name).to eq expected_encoding
     end
   end
 
   describe 'with utf-8 strings' do
     let(:string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
+    let(:expected_encoding){ 'UTF-8' }
     let(:random_string){ string + random_key }
 
     include_examples 'CRDTs with weird names'
@@ -69,6 +88,7 @@ describe 'Encoding and CRDTs', integration: true, search_config: true do
 
   describe 'with binary strings' do
     let(:string){ "\xff\xff".force_encoding('binary') }
+    let(:expected_encoding){ 'ASCII-8BIT' }
     let(:random_string){ string + random_key }
 
     include_examples 'CRDTs with weird names'

data/spec/integration/riak/protobuffs/timeouts_spec.rb

@@ -5,170 +5,174 @@ require 'riak/client/beefcake/messages'
 require 'riak/client/beefcake/protocol'
 
 describe 'Protocol Buffers', test_client: true, integration: true do
-  describe 'timeouts' do
-    it 'raises error on connect timeout' do
-      # unroutable TEST-NET (https://tools.ietf.org/html/rfc5737)
-      config = {}
-      config[:host] = '192.0.2.0'
-      config[:pb_port] = 65535
-
-      config[:connect_timeout] = 0.0001
-      client = Riak::Client.new(config)
-
-      expect do
-        client.ping
-      end.to raise_error RuntimeError, /timed out/
-    end
-
-    it 'raises error on read timeout' do
-      ok_to_continue = false
-      quitting = false
-      port = 0
+  if RUBY_VERSION >= '2.0.0'
+    describe 'timeouts' do
+      it 'raises error on connect timeout' do
+        # unroutable TEST-NET (https://tools.ietf.org/html/rfc5737)
+        config = {}
+        config[:host] = '192.0.2.0'
+        config[:pb_port] = 65535
+
+        config[:connect_timeout] = 0.0001
+        client = Riak::Client.new(config)
+
+        expect do
+          client.ping
+        end.to raise_error RuntimeError, /timed out/
+      end
 
-      server = nil
-      thr = Thread.new do
-        server = TCPServer.new port
-        port = server.addr[1]
-        ok_to_continue = true
-        loop do
-          begin
-            Thread.start(server.accept) do |s|
-              loop do
-                p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
-                begin
-                  msgname, _body = p.receive
-                rescue IOError
-                  break if quitting
-                  raise
-                end
-                case msgname
-                when :PingReq
-                  sleep 0.5
-                  p.write :PingResp
-                else
-                  $stderr.puts("unknown msgname: #{msgname}")
+      it 'raises error on read timeout' do
+        ok_to_continue = false
+        quitting = false
+        port = 0
+
+        server = nil
+        thr = Thread.new do
+          server = TCPServer.new port
+          port = server.addr[1]
+          ok_to_continue = true
+          loop do
+            begin
+              Thread.start(server.accept) do |s|
+                loop do
+                  p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
+                  begin
+                    msgname, _body = p.receive
+                  rescue IOError
+                    break if quitting
+                    raise
+                  end
+                  case msgname
+                  when :PingReq
+                    sleep 0.5
+                    p.write :PingResp
+                  else
+                    $stderr.puts("unknown msgname: #{msgname}")
+                  end
                 end
               end
+            rescue IOError
+              break if quitting
+              raise
             end
-          rescue IOError
-            break if quitting
-            raise
           end
         end
-      end
 
-      loop do
-        break if ok_to_continue
-        sleep 0.1
-      end
-      ok_to_continue = false
-
-      config = {}
-      config[:pb_port] = port
-      config[:client_id] = port
-      config[:read_timeout] = 0.0001
-      client = Riak::Client.new(config)
-
-      max_ping_attempts = 16
-      ping_count = 0
-      loop do
-        begin
-          client.ping
-          ping_count += 1
-          break if ping_count > max_ping_attempts
-        rescue RuntimeError => e
-          break if e.message =~ /timed out/
+        loop do
+          break if ok_to_continue
+          sleep 0.1
         end
-        sleep 0.5
-      end
-
-      quitting = true
-      server.close
-      thr.join
+        ok_to_continue = false
 
-      expect(ping_count).to be < max_ping_attempts
-    end
-
-    it 'raises error on write timeout' do
-      ok_to_continue = false
-      quitting = false
-      port = 0
+        config = {}
+        config[:pb_port] = port
+        config[:client_id] = port
+        config[:read_timeout] = 0.0001
+        client = Riak::Client.new(config)
 
-      server = nil
-      thr = Thread.new do
-        server = TCPServer.new port
-        port = server.addr[1]
-        ok_to_continue = true
+        max_ping_attempts = 16
+        ping_count = 0
         loop do
           begin
-            Thread.start(server.accept) do |s|
-              loop do
-                p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
-                begin
-                  msgname, _body = p.receive
-                rescue IOError
-                  break if quitting
-                  raise
-                end
-                case msgname
-                when :PingReq
-                  p.write :PingResp
-                when :GetServerInfoReq
-                  r = Riak::Client::BeefcakeProtobuffsBackend::RpbGetServerInfoResp.new
-                  r.node = 'dev1@127.0.0.1'.force_encoding('BINARY')
-                  r.server_version = '2.1.4'.force_encoding('BINARY')
-                  p.write :GetServerInfoResp, r
-                when :PutReq
-                  r = Riak::Client::BeefcakeProtobuffsBackend::RpbPutResp.new
-                  p.write :PutResp, r
-                else
-                  $stderr.puts("unknown msgname: #{msgname}")
+            client.ping
+            ping_count += 1
+            break if ping_count > max_ping_attempts
+          rescue RuntimeError => e
+            break if e.message =~ /timed out/
+          end
+          sleep 0.5
+        end
+
+        quitting = true
+        server.close
+        thr.join
+
+        expect(ping_count).to be < max_ping_attempts
+      end
+
+      it 'raises error on write timeout' do
+        ok_to_continue = false
+        quitting = false
+        port = 0
+
+        server = nil
+        thr = Thread.new do
+          server = TCPServer.new port
+          port = server.addr[1]
+          ok_to_continue = true
+          loop do
+            begin
+              Thread.start(server.accept) do |s|
+                loop do
+                  p = Riak::Client::BeefcakeProtobuffsBackend::Protocol.new s
+                  begin
+                    msgname, _body = p.receive
+                  rescue IOError
+                    break if quitting
+                    raise
+                  end
+                  case msgname
+                  when :PingReq
+                    p.write :PingResp
+                  when :GetServerInfoReq
+                    r = Riak::Client::BeefcakeProtobuffsBackend::RpbGetServerInfoResp.new
+                    r.node = 'dev1@127.0.0.1'.force_encoding('BINARY')
+                    r.server_version = '2.1.4'.force_encoding('BINARY')
+                    p.write :GetServerInfoResp, r
+                  when :PutReq
+                    r = Riak::Client::BeefcakeProtobuffsBackend::RpbPutResp.new
+                    p.write :PutResp, r
+                  else
+                    $stderr.puts("unknown msgname: #{msgname}")
+                  end
                 end
               end
+            rescue IOError
+              break if quitting
+              raise
             end
-          rescue IOError
-            break if quitting
-            raise
           end
         end
-      end
 
-      loop do
-        break if ok_to_continue
-        sleep 0.1
-      end
-      ok_to_continue = false
-
-      config = {}
-      config[:pb_port] = port
-      config[:client_id] = port
-      config[:write_timeout] = 0.0001
-      client = Riak::Client.new(config)
-
-      bucket = client.bucket('timeouts')
-
-      max_store_attempts = 16
-      store_count = 0
-      loop do
-        begin
-          obj = bucket.new "obj-#{store_count}"
-          # write enough data to grow beyond socket buffer capacity
-          obj.data = SecureRandom.urlsafe_base64(10_000_000)
-          obj.content_type = 'text/plain'
-          obj.store
-          store_count += 1
-          break if store_count > max_store_attempts
-        rescue RuntimeError => e
-          break if e.message =~ /timed out/
+        loop do
+          break if ok_to_continue
+          sleep 0.1
         end
-        sleep 0.5
-      end
+        ok_to_continue = false
 
-      quitting = true
-      server.close
-      thr.join
+        config = {}
+        config[:pb_port] = port
+        config[:client_id] = port
+        config[:write_timeout] = 0.0001
+        client = Riak::Client.new(config)
 
-      expect(store_count).to be < max_store_attempts
+        bucket = client.bucket('timeouts')
+
+        max_store_attempts = 16
+        store_count = 0
+        loop do
+          begin
+            obj = bucket.new "obj-#{store_count}"
+            # write enough data to grow beyond socket buffer capacity
+            obj.data = SecureRandom.urlsafe_base64(10_000_000)
+            obj.content_type = 'text/plain'
+            obj.store
+            store_count += 1
+            break if store_count > max_store_attempts
+          rescue RuntimeError => e
+            break if e.message =~ /timed out/
+          end
+          sleep 0.5
+        end
+
+        quitting = true
+        server.close
+        thr.join
+
+        expect(store_count).to be < max_store_attempts
+      end
     end
+  else
+    skip 'not supported in this version of Ruby'
   end
 end