riak-client 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dd52a7e386245c3d3dc1d7c1be2ba94b3dd2c91
-  data.tar.gz: 48ed739d11831361ca42d2c8291753c9d87c7124
+  metadata.gz: 90e4c5dd56ba3d2a7ea13534ba0d15f0bd7b2119
+  data.tar.gz: e1c2afdbb12543c942f7d58bf15d9f5c07f40f03
 SHA512:
-  metadata.gz: dc420b627bd2854197b03468a4aaf09895eb267f601fb285280788ff73754266b098d9fac1251354f662853eb8e4c73973a75874d040e9fa3019a64adac6d86a
-  data.tar.gz: f07cc587b55e1b54662b86f3ca572df999f89511ed8ae340ed935848a410d5b9bcb7947f7cc96a569121ddc270e595eedf9e19518f1266fa0cbe7b7d04e5229a
+  metadata.gz: ab4b31f98818b08370d58a6379ce9a607ab9aabdbc09efddf1cc40a2f45af7d45252add5dbdfb4f562c5ad9d21bf40ad4a1f3506c4ba5ba4ed2eaa98a244c356
+  data.tar.gz: f6241dbd209b254d53024eca1db750789aaa6ec031ea53483b34dbb315317d0bf94d80570edd6cf92dba841092c9d6a90ffc3a3f12b3cfeeb3e8c1ae64e9e44e

data/RELEASE_NOTES.md

@@ -1,5 +1,28 @@
 # Riak Ruby Client Release Notes
 
+## 2.2.1 Release - 2015-06-19
+
+Version 2.2.1 is a bugfix release, and includes additional testing of character
+encodings.
+
+Bug fixes:
+
+* Support bucket-typed buckets when creating secondary-index input phases
+  for map-reduce, thanks to Takeshi Akima.
+* Support Riak Search 2 / Yokozuna results as input phases for map-reduce,
+  thanks again to Takeshi Akima.
+* `BucketTyped::Bucket#get_index` now includes the bucket type name in the
+  2i request.
+* `Bucket#==` now performs an encoding-independent comparison on bucket names.
+* `BucketType#==` also does an encoding-independent comparison on type names.
+
+Testing enhancements:
+
+* Non-ASCII UTF-8 strings, and binary strings containing byte 255 are tested
+  with key-value, secondary index, CRDT, and Riak Search interfaces. These
+  findings are available on our documentation site:
+  http://basho.github.io/riak-ruby-client/encoding.html
+
 ## 2.2.0 Release - 2015-05-27
 
 Version 2.2.0 is a feature release.

data/lib/riak/bucket.rb

@@ -33,6 +33,10 @@ module Riak
     # If a block is given, keys will be streamed through
     # the block (useful for large buckets). When streaming,
     # results of the operation will not be returned to the caller.
+    #
+    # Returned keys will be in binary encoding regardless of the key's original
+    # encoding.
+    #
     # @yield [Array<String>] a list of keys from the current chunk
     # @return [Array<String>] Keys in this bucket
     # @note This operation has serious performance implications and
@@ -290,7 +294,11 @@ module Riak
     def ==(other)
       return false unless self.class == other.class
       return false unless self.client == other.client
-      return false unless self.name == other.name
+      return true if self.name.nil? && other.name.nil?
+      unless self.name.respond_to?(:bytes) && other.name.respond_to?(:bytes)
+        return false
+      end
+      return false unless self.name.bytes == other.name.bytes
       true
     end
   end

data/lib/riak/bucket_type.rb

@@ -70,7 +70,7 @@ module Riak
     def ==(other)
       return false unless self.class == other.class
       return false unless self.client == other.client
-      return false unless self.name == other.name
+      return false unless self.name.bytes == other.name.bytes
       true
     end
   end

data/lib/riak/bucket_typed/bucket.rb

@@ -98,6 +98,17 @@ module Riak
         end
       end
 
+      # Queries a secondary index on the bucket-typed bucket.
+      # @note This will only work if your Riak installation supports 2I.
+      # @param [String] index the name of the index
+      # @param [String,Integer,Range] query the value of the index, or a
+      #   Range of values to query
+      # @return [Array<String>] a list of keys that match the index
+      #   query
+      def get_index(index, query, options = {  })
+        super index, query, o(options)
+      end
+
       # Does this {BucketTyped::Bucket} have a non-default bucket type?
       # @return [Boolean] true if this bucket has a non-default type.
       def needs_type?

data/lib/riak/map_reduce.rb

@@ -110,12 +110,13 @@ module Riak
     end
 
     # (Riak Search) Use a search query to start a map/reduce job.
-    # @param [String, Bucket] bucket the bucket/index to search
+    # @param [String,Riak::Search::Index] index the index to query, either a
+    #   {Riak::Search::Index} instance or a {String}
     # @param [String] query the query to run
     # @return [MapReduce] self
-    def search(bucket, query)
-      bucket = bucket.name if bucket.respond_to?(:name)
-      @inputs = {:module => "riak_search", :function => "mapred_search", :arg => [bucket, query]}
+    def search(index, query)
+      index = index.name if index.respond_to?(:name)
+      @inputs = {:module => "yokozuna", :function => "mapred_search", :arg => [index, query]}
       self
     end
 
@@ -127,13 +128,18 @@ module Riak
     #   a range of values (of Strings or Integers)
     # @return [MapReduce] self
     def index(bucket, index, query)
-      bucket = bucket.name if bucket.respond_to?(:name)
+      if bucket.is_a? Bucket
+        bucket = bucket.needs_type? ? [maybe_escape(bucket.type.name), maybe_escape(bucket.name)] : maybe_escape(bucket.name)
+      else
+        bucket = maybe_escape(bucket)
+      end
+
       case query
       when String, Fixnum
-        @inputs = {:bucket => maybe_escape(bucket), :index => index, :key => query}
+        @inputs = {:bucket => bucket, :index => index, :key => query}
       when Range
         raise ArgumentError, t('invalid_index_query', :value => query.inspect) unless String === query.begin || Integer === query.begin
-        @inputs = {:bucket => maybe_escape(bucket), :index => index, :start => query.begin, :end => query.end}
+        @inputs = {:bucket => bucket, :index => index, :start => query.begin, :end => query.end}
       else
         raise ArgumentError, t('invalid_index_query', :value => query.inspect)
       end

data/lib/riak/rcontent.rb

@@ -58,7 +58,8 @@ module Riak
       end
     end
 
-    # @return [Object] the unmarshaled form of {#raw_data} stored in riak at this object's key
+    # @return [Object] the unmarshaled form of {#raw_data} stored in riak at
+    #   this object's key
     def data
       if @raw_data && !@data
         raw = @raw_data.respond_to?(:read) ? @raw_data.read : @raw_data
@@ -82,7 +83,6 @@ module Riak
       @data = new_data
     end
 
-
     # @return [String] raw data stored in riak for this object's key
     def raw_data
       if @data && !@raw_data

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

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

@@ -0,0 +1,76 @@
+# coding: utf-8
+require 'spec_helper'
+require 'riak'
+
+describe 'Encoding and CRDTs', integration: true, search_config: true do
+  shared_examples 'CRDTs with weird names' do
+    let(:counter_bucket) do
+      test_client.bucket_type('counters').bucket(random_string)
+    end
+    let(:map_bucket) do
+      test_client.bucket_type('maps').bucket(random_string)
+    end
+    let(:set_bucket) do
+      test_client.bucket_type('sets').bucket(random_string)
+    end
+
+    it 'creates counters' do
+      counter = nil
+      expect{ counter = Riak::Crdt::Counter.new counter_bucket, random_string }.
+        to_not raise_error
+
+      expect(counter).to be_a Riak::Crdt::Counter
+
+      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{ 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
+    end
+
+    it 'updates sets' do
+      set = nil
+      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
+
+      set.add random_string
+
+      expect(set.members).to include random_string
+
+      set.remove random_string
+
+      expect(set.members).to_not include random_string
+    end
+  end
+
+  describe 'with utf-8 strings' do
+    let(:string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
+    let(:random_string){ string + random_key }
+
+    include_examples 'CRDTs with weird names'
+  end
+
+  describe 'with binary strings' do
+    let(:string){ "\xff\xff".force_encoding('binary') }
+    let(:random_string){ string + random_key }
+
+    include_examples 'CRDTs with weird names'
+  end
+end

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

@@ -0,0 +1,81 @@
+# coding: utf-8
+require 'spec_helper'
+require 'riak'
+
+describe 'Encoding and Riak KV', integration: true, test_client: true do
+  let(:bucket_type){ test_client.bucket_type 'yokozuna' }
+
+  let(:utf8_encoding){ Encoding.find 'utf-8' }
+  let(:utf8_string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
+  let(:random_utf8_string){ utf8_string + random_key }
+  let(:utf8_bucket){ bucket_type.bucket random_utf8_string }
+
+  let(:binary_encoding){ Encoding.find 'binary' }
+  let(:binary_string){ "\xff\xff".force_encoding('binary') }
+  let(:random_binary_string){ binary_string + random_key }
+  let(:binary_bucket){ bucket_type.bucket random_binary_string }
+
+  it 'encodes the test strings correctly' do
+    expect(utf8_string.encoding).to eq utf8_encoding
+    expect(random_utf8_string.encoding).to eq utf8_encoding
+    expect(binary_string.encoding).to eq binary_encoding
+    expect(random_binary_string.encoding).to eq binary_encoding
+  end
+
+  describe 'key-value operations' do
+    it 'allows utf-8 strings in bucket and key names, values, and 2i' do
+      expect(utf8_bucket).to be_a Riak::Bucket
+      expect(robj = utf8_bucket.new(random_utf8_string)).to be_a Riak::RObject
+      robj.content_type = 'text/plain'
+      robj.data = random_utf8_string
+      robj.indexes['cat_bin'] = [random_utf8_string, 'asdf']
+      expect{ robj.store }.to_not raise_error
+
+      expect(robj2 = utf8_bucket.get(random_utf8_string)).to be_a Riak::RObject
+      expect(robj2.data).to eq random_utf8_string
+
+      robj.raw_data = random_utf8_string
+      robj.store
+      robj2.reload
+      expect(robj2.raw_data).to eq random_utf8_string
+      expect(robj2.indexes['cat_bin']).to include 'asdf'
+      expect(robj2.indexes['cat_bin']).
+        to include random_utf8_string.force_encoding('binary')
+
+      expect(utf8_bucket.get_index 'cat_bin', 'asdf').
+        to include random_utf8_string.force_encoding('binary')
+      expect(utf8_bucket.get_index 'cat_bin', random_utf8_string).
+        to include random_utf8_string.force_encoding('binary')
+
+      # riak gives us binary-encoding back, which is working as intended
+      expect(utf8_bucket.keys).
+        to include random_utf8_string.force_encoding('binary')
+    end
+
+    it 'allows binary strings in bucket and key names and values' do
+      expect(binary_bucket).to be_a Riak::Bucket
+      expect(robj = binary_bucket.new(random_binary_string)).
+        to be_a Riak::RObject
+      robj.content_type = 'text/plain'
+      robj.data = random_binary_string
+      robj.indexes['cat_bin'] = [random_binary_string, 'asdf']
+      expect{ robj.store }.to_not raise_error
+
+      expect(robj2 = binary_bucket.get(random_binary_string)).
+        to be_a Riak::RObject
+      expect(robj2.data).to eq random_binary_string
+
+      robj.raw_data = random_binary_string
+      robj.store
+      robj2.reload
+      expect(robj2.raw_data).to eq random_binary_string
+
+      expect(binary_bucket.get_index 'cat_bin', 'asdf').
+        to include random_binary_string
+      expect(binary_bucket.get_index 'cat_bin', random_binary_string).
+        to include random_binary_string
+
+      expect(binary_bucket.keys).to include random_binary_string
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# coding: utf-8
+require 'spec_helper'
+require 'riak'
+
+describe 'Encoding and Riak Search', integration: true, search_config: true do
+  let(:bucket_type){ test_client.bucket_type 'yokozuna' }
+
+  let(:utf8_encoding){ Encoding.find 'utf-8' }
+  let(:utf8_string){ "\xF0\x9F\x9A\xB4こんにちはสวัสดี" }
+  let(:random_utf8_string){ utf8_string + random_key }
+  let(:utf8_bucket){ bucket_type.bucket random_utf8_string }
+
+  let(:binary_encoding){ Encoding.find 'binary' }
+  let(:binary_string){ "\xff\xff".force_encoding('binary') }
+  let(:random_binary_string){ binary_string + random_key }
+  let(:binary_bucket){ bucket_type.bucket random_binary_string }
+
+  describe 'with utf-8 strings' do
+    it 'creates schemas' do
+      schema = nil
+      expect do
+        schema = Riak::Search::Schema.new test_client, random_utf8_string
+      end.to_not raise_error
+
+      expect(schema).to be_a Riak::Search::Schema
+
+      expect{ schema.create! schema_xml random_utf8_string }.to_not raise_error
+
+      schema2 = Riak::Search::Schema.new test_client, random_utf8_string
+      expect(schema2).to be_exists
+    end
+
+    it 'refuses to create indexes' do
+      index = nil
+      expect do
+        index = Riak::Search::Index.new test_client, random_utf8_string
+      end.to_not raise_error
+
+      expect(index).to be_a Riak::Search::Index
+
+      expect{ index.create! }.to raise_error /Invalid character/
+    end
+
+    it 'queries non-weird indexes' do
+      create_index
+
+      props = Riak::BucketProperties.new utf8_bucket
+      props['search_index'] = index_name
+      props.store
+
+      wait_until do
+        props.reload
+        props['search_index'] == index_name
+      end
+
+      robj = utf8_bucket.new random_utf8_string
+      robj.content_type = 'text/plain'
+      robj.raw_data = <<EOD
+This is due to the write-once, append-only nature of the Bitcask database files.
+High throughput, especially when writing an incoming stream of random items
+Because the data being written doesn't need to be ordered on disk and because
+the log structured design allows for minimal disk head movement during writes
+these operations generally saturate the I/O and disk bandwidth.
+EOD
+      robj.store
+
+      results = nil
+      wait_until do
+        results = index.query('bitcask').results
+        !results.empty?
+      end
+      expect(results).to_not be_empty
+      expect(results.docs.first.bucket_type).to eq robj.bucket.type
+      expect(results.docs.first.bucket).to eq robj.bucket
+      expect(results.docs.first.key.bytes).to eq robj.key.bytes
+    end
+  end
+
+  describe 'with binary strings' do
+    it 'refuses to create schemas' do
+      schema = nil
+      expect do
+        schema = Riak::Search::Schema.new test_client, random_binary_string
+      end.to_not raise_error
+
+      expect(schema).to be_a Riak::Search::Schema
+
+      # yz will refuse to create files with names that aren't valid utf-8
+      expect{ schema.create! schema_xml random_binary_string }.
+        to raise_error /bad_character/
+    end
+
+
+    it 'refuses to create indexes' do
+      index = nil
+      expect do
+        index = Riak::Search::Index.new test_client, random_binary_string
+      end.to_not raise_error
+
+      expect(index).to be_a Riak::Search::Index
+
+      expect{ index.create! }.to raise_error /Invalid character/
+    end
+
+    # left here for reference: yz can't index documents with \xff\xff in the
+    # key, or presumably bucket name either
+    #     it 'queries non-weird indexes' do
+    #       create_index
+
+    #       props = Riak::BucketProperties.new binary_bucket
+    #       props['search_index'] = index_name
+    #       props.store
+
+    #       wait_until do
+    #         props.reload
+    #         props['search_index'] == index_name
+    #       end
+
+    #       robj = binary_bucket.new random_binary_string
+    #       robj.content_type = 'text/plain'
+    #       robj.raw_data = <<EOD
+    # This is due to the write-once, append-only nature of the Bitcask database files.
+    # High throughput, especially when writing an incoming stream of random items
+    # Because the data being written doesn't need to be ordered on disk and because
+    # the log structured design allows for minimal disk head movement during writes
+    # these operations generally saturate the I/O and disk bandwidth.
+    # EOD
+    #       robj.store
+
+    #       results = nil
+    #       wait_until do
+    #         results = index.query('bitcask').results
+    #         !results.empty?
+    #       end
+    #       expect(results).to_not be_empty
+    #       expect(results.docs.first.bucket_type).to eq robj.bucket.type
+    #       expect(results.docs.first.bucket).to eq robj.bucket
+    #       expect(results.docs.first.key.bytes).to eq robj.key.bytes
+    #     end
+  end
+end

data/spec/riak/bucket_typed/bucket_spec.rb

@@ -59,4 +59,20 @@ describe Riak::BucketTyped::Bucket do
      expect{ subject.props = { 'allow_mult' => true } }.to_not raise_error
     end
   end
+
+  describe "querying an index" do
+    it "attaches the bucket type" do
+      expect(client).
+        to receive(:get_index).
+            with(subject, 'test_bin', 'testing', { type: 'type' }).
+            and_return(
+              Riak::IndexCollection.new_from_json({
+                                                    keys: ['asdf']
+                                                  }.to_json))
+
+      result = subject.get_index('test_bin', 'testing')
+      expect(result).to be_a Riak::IndexCollection
+      expect(result.to_a).to eq %w{asdf}
+    end
+  end
 end

data/spec/riak/map_reduce_spec.rb

@@ -129,6 +129,13 @@ describe Riak::MapReduce do
     end
 
     context "using secondary indexes as inputs" do
+      it "set the inputs for a bucket-typed bucket" do
+        expect(mr.index(typed_bucket, "email_bin", "sean@basho.com")).to eq(mr)
+        expect(mr.inputs).to eq(bucket: [typed_bucket.type.name, typed_bucket.name],
+                                index: "email_bin",
+                                key: "sean@basho.com")
+      end
+
       it "sets the inputs for equality" do
         expect(mr.index("foo", "email_bin", "sean@basho.com")).to eq(mr)
         expect(mr.inputs).to eq(bucket: "foo",

data/spec/riak/search_spec.rb

@@ -85,20 +85,20 @@ describe "Search features" do
     end
 
     describe "using a search query as inputs" do
-      it "accepts a bucket name and query" do
+      it "accepts a index name and query" do
         @mr.search("foo", "bar OR baz")
-        expect(@mr.inputs).to eq({:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
+        expect(@mr.inputs).to eq({:module => "yokozuna", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
       end
 
-      it "accepts a Riak::Bucket and query" do
-        @mr.search(Riak::Bucket.new(@client, "foo"), "bar OR baz")
-        expect(@mr.inputs).to eq({:module => "riak_search", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
+      it "accepts a Riak::Search::Index and query" do
+        @mr.search(Riak::Search::Index.new(@client, "foo"), "bar OR baz")
+        expect(@mr.inputs).to eq({:module => "yokozuna", :function => "mapred_search", :arg => ["foo", "bar OR baz"]})
       end
 
       it "emits the Erlang function and arguments" do
         @mr.search("foo", "bar OR baz")
         expect(@mr.to_json).to include('"inputs":{')
-        expect(@mr.to_json).to include('"module":"riak_search"')
+        expect(@mr.to_json).to include('"module":"yokozuna"')
         expect(@mr.to_json).to include('"function":"mapred_search"')
         expect(@mr.to_json).to include('"arg":["foo","bar OR baz"]')
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: riak-client
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Bryce Kerley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-27 00:00:00.000000000 Z
+date: 2015-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -310,6 +310,9 @@ files:
 - spec/integration/riak/crdt_spec.rb
 - spec/integration/riak/crdt_validation/map_spec.rb
 - spec/integration/riak/crdt_validation/set_spec.rb
+- spec/integration/riak/encodings/crdt_spec.rb
+- spec/integration/riak/encodings/kv_spec.rb
+- spec/integration/riak/encodings/yz_spec.rb
 - spec/integration/riak/preflist_spec.rb
 - spec/integration/riak/properties_spec.rb
 - spec/integration/riak/protobuffs/interrupted_request_spec.rb
@@ -407,7 +410,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: riak-client is a rich client for Riak, the distributed database by Basho.
@@ -433,6 +436,9 @@ test_files:
 - spec/integration/riak/crdt_spec.rb
 - spec/integration/riak/crdt_validation/map_spec.rb
 - spec/integration/riak/crdt_validation/set_spec.rb
+- spec/integration/riak/encodings/crdt_spec.rb
+- spec/integration/riak/encodings/kv_spec.rb
+- spec/integration/riak/encodings/yz_spec.rb
 - spec/integration/riak/preflist_spec.rb
 - spec/integration/riak/properties_spec.rb
 - spec/integration/riak/protobuffs/interrupted_request_spec.rb