riak-client 2.2.2 → 2.3.0

data/lib/riak/time_series/collection.rb

@@ -0,0 +1,5 @@
+module Riak::TimeSeries
+  class Collection < Array
+    attr_accessor :columns
+  end
+end

data/lib/riak/time_series/deletion.rb

@@ -0,0 +1,26 @@
+module Riak::TimeSeries
+
+  # Delete entries from Riak Time Series.
+  class Deletion
+    attr_accessor :key
+    attr_accessor :options
+
+    attr_reader :client
+    attr_reader :table_name
+
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+      @options = Hash.new
+    end
+
+    def delete!
+      client.backend do |be|
+        be.time_series_delete_operator.delete(table_name,
+                                              key,
+                                              options)
+      end
+      true
+    end
+  end
+end

data/lib/riak/time_series/list.rb

@@ -0,0 +1,66 @@
+module Riak::TimeSeries
+
+  # A request to list keys in a Riak Time Series collection. Very expensive,
+  # not recommended for use in production.
+  class List
+    include Riak::Util::Translation
+
+    # @!attribute [r] table_name
+    # @return [String] the table name to list keys in
+    attr_reader :table_name
+
+    # @!attribute [r] client
+    # @return [Riak::Client] the Riak client to use for the list keys operation
+    attr_reader :client
+
+    # @!attribute [rw] timeout
+    # @return [Integer] how many milliseconds Riak should wait for listing
+    attr_accessor :timeout
+
+    # @!attribute [r] results
+    # @return [Riak::TimeSeries::Collection<Riak::TimeSeries::Row>] each key
+    #   as a row in a collection; nil if keys were streamed to a block
+    attr_reader :results
+
+    # Initializes but does not issue the list keys operation
+    #
+    # @param [Riak::Client] client the Riak Client to list keys with
+    # @param [String] table_name the table name to list keys in
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+      @timeout = nil
+    end
+
+    # Issue the list keys request. Takes a block for streaming results, or
+    # sets the #results read-only attribute iff no block is given.
+    #
+    # @yieldparam key [Riak::TimeSeries::Row] a listed key
+    def issue!(&block)
+      list_keys_warning(caller)
+
+      options = { timeout: self.timeout }
+
+      potential_results = nil
+
+      client.backend do |be|
+        potential_results = be.time_series_list_operator.list(table_name,
+                                                              block,
+                                                              options)
+      end
+
+      return @results = potential_results unless block_given?
+
+      true
+    end
+
+    private
+    def list_keys_warning(bound_caller)
+      return if Riak.disable_list_keys_warnings
+
+      backtrace = bound_caller.join("\n    ")
+
+      warn(t('time_series.list_keys'), backtrace: backtrace)
+    end
+  end
+end

data/lib/riak/time_series/query.rb

@@ -0,0 +1,43 @@
+module Riak::TimeSeries
+
+  # A query for Riak Time Series. Supports SQL for querying (data
+  # manipulation language, or DML).
+  class Query
+
+    # @!attribute [rw] query_text
+    # @return [String] the SQL query to run
+    attr_accessor :query_text
+
+    # Values to be interpolated into the query, support planned in Riak TS
+    # 1.2
+    attr_accessor :interpolations
+
+    # @!attribute [r] client
+    # @return [Riak::Client] the Riak client to use for the TS query
+    attr_reader :client
+
+    # #!attribute [r] results
+    # @return [Riak::Client::BeefcakeProtobuffsBackend::TsQueryResp]
+    #   backend-dependent results object
+    attr_reader :results
+
+    # Initialize a query object
+    #
+    # @param [Riak::Client] client the client connected to the riak cluster
+    # @param [String] query_text the SQL query to run
+    # @param interpolations planned for Riak TS 1.1
+    def initialize(client, query_text, interpolations = {})
+      @client = client
+      @query_text = query_text
+      @interpolations = interpolations
+    end
+
+    # Run the query against Riak TS, and store the results in the `results`
+    # attribute
+    def issue!
+      @results = client.backend do |be|
+        be.time_series_query_operator.query(query_text, interpolations)
+      end
+    end
+  end
+end

data/lib/riak/time_series/read.rb

@@ -0,0 +1,18 @@
+module Riak::TimeSeries
+  class Read
+    attr_accessor :key
+    attr_reader :client
+    attr_reader :table_name
+
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+    end
+
+    def read!
+      client.backend do |be|
+        be.time_series_get_operator.get(table_name, key)
+      end
+    end
+  end
+end

data/lib/riak/time_series/row.rb

@@ -0,0 +1,4 @@
+module Riak::TimeSeries
+  class Row < Array
+  end
+end

data/lib/riak/time_series/submission.rb

@@ -0,0 +1,32 @@
+module Riak::TimeSeries
+  class Submission
+
+    # @!attributes [rw] measurements
+    # @return [Array<Array<Object>>] measurements to write to Riak TS
+    attr_accessor :measurements
+
+    # @!attribute [r] client
+    # @return [Riak::Client] the client to write submissions to
+    attr_reader :client
+
+    # @!attribute [r] table_name
+    # @return [String] the table name to write submissions to
+    attr_reader :table_name
+
+    # Initializes the submission object with a client and table name
+    #
+    # @param [Riak::Client] client the client connected to the Riak TS cluster
+    # @param [String] table_name the table name in the cluster
+    def initialize(client, table_name)
+      @client = client
+      @table_name = table_name
+    end
+
+    # Write the submitted data to Riak.
+    def write!
+      client.backend do |be|
+        be.time_series_put_operator.put(table_name, measurements)
+      end
+    end
+  end
+end

data/lib/riak/time_series.rb

@@ -0,0 +1,17 @@
+module Riak
+
+  # Container module for Riak Time Series features.
+  module TimeSeries
+  end
+end
+
+require 'riak/errors/time_series'
+
+require 'riak/time_series/collection'
+require 'riak/time_series/row'
+
+require 'riak/time_series/deletion'
+require 'riak/time_series/list'
+require 'riak/time_series/query'
+require 'riak/time_series/submission'
+require 'riak/time_series/read'

data/lib/riak/version.rb

@@ -1,3 +1,3 @@
 module Riak
-  VERSION = "2.2.2"
+  VERSION = "2.3.0"
 end

data/lib/riak.rb

@@ -13,11 +13,27 @@ module Riak
   module Util; end
   extend Util::Translation
 
+  class NullLogger
+    def fatal(msg) end
+
+    def error(msg) end
+
+    def warn(msg)  end
+
+    def info(msg)  end
+
+    def debug(msg) end
+  end
+
   class << self
     # Only change this if you really know what you're doing. Better to
     # err on the side of caution and assume you don't.
     # @private
     attr_accessor :disable_list_keys_warnings
+
+    # Set a custom logger object (e.g. Riak.logger = Rails.logger)
+    attr_accessor :logger
   end
   self.disable_list_keys_warnings = false
+  self.logger = NullLogger.new
 end

data/spec/integration/riak/bucket_types_spec.rb

@@ -162,15 +162,15 @@ describe 'Bucket Types', test_client: true, integration: true do
       let(:untyped_bucket){ test_client.bucket bucket.name }
 
       it 'allows reading and writing bucket properties' do
-        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to_not be
-        expect(test_client.get_bucket_props(untyped_bucket)['last_write_wins']).to_not be
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['notfound_ok']).to be
+        expect(test_client.get_bucket_props(untyped_bucket)['notfound_ok']).to be
 
         # test setting
-        expect{ bucket.props = {'last_write_wins' => true} }.to_not raise_error
+        expect{ bucket.props = {'notfound_ok' => false} }.to_not raise_error
 
         # make sure setting doesn't leak to untyped bucket
-        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to be
-        expect(test_client.get_bucket_props(untyped_bucket)['last_write_wins']).to_not be
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['notfound_ok']).to_not be
+        expect(test_client.get_bucket_props(untyped_bucket)['notfound_ok']).to be
 
         # add canary setting on untyped bucket
         expect{ untyped_bucket.props = { 'n_val' => 1} }.to_not raise_error
@@ -183,7 +183,7 @@ describe 'Bucket Types', test_client: true, integration: true do
         expect{ bucket.clear_props }.to_not raise_error
 
         # make sure clearing doesn't leak to canary setting on untyped bucket
-        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['last_write_wins']).to_not be
+        expect(test_client.get_bucket_props(bucket, type: 'yokozuna')['notfound_ok']).to be
         expect(test_client.get_bucket_props(untyped_bucket)['n_val']).to eq 1
       end
     end

data/spec/integration/riak/time_series_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'riak'
+
+describe 'Time Series',
+         test_client: true, integration: true, time_series: true do
+  let(:table_name){ 'GeoCheckin' }
+
+  let(:now){ Time.at(Time.now.to_i) }
+  let(:five_minutes_ago){ now - 300 }
+  let(:now_range_str) do
+    past = (now.to_i - 100) * 1000
+    future = (now.to_i + 100) * 1000
+    "time > #{ past } AND time < #{ future }"
+  end
+  let(:never_range_str) do
+    range_start = '1'
+    range_end = '2'
+    "time > #{range_start} AND time < #{range_end}"
+  end
+
+  let(:family){ 'family-' + random_key }
+  let(:series){ 'series-' + random_key }
+
+  let(:key){ [family, series, now] }
+  let(:key2){ [family, series, five_minutes_ago] }
+  let(:datum){ [*key, 'cloudy', 27.1] }
+  let(:datum_null){ [*key2, 'cloudy', nil] }
+
+  let(:family_series_str) do
+    "myfamily = '#{family}' AND myseries = '#{series}'"
+  end
+
+  let(:query) do
+    <<-SQL
+SELECT * FROM #{table_name}
+WHERE
+  #{family_series_str} AND
+  #{now_range_str}
+SQL
+  end
+    let(:no_data_query) do
+    <<-SQL
+SELECT * FROM #{table_name}
+WHERE
+  #{family_series_str} AND
+  #{never_range_str}
+SQL
+  end
+
+  let(:stored_datum_expectation) do
+    submission = Riak::TimeSeries::Submission.new test_client, table_name
+    submission.measurements = [datum]
+    expect{ submission.write! }.to_not raise_error
+  end
+
+  let(:stored_datum_null_expectation) do
+    submission = Riak::TimeSeries::Submission.new test_client, table_name
+    submission.measurements = [datum_null]
+    expect{ submission.write! }.to_not raise_error
+  end
+
+  describe 'query interface' do
+    subject{ Riak::TimeSeries::Query.new test_client, query }
+    let(:subject_without_data) do
+      Riak::TimeSeries::Query.new test_client, no_data_query
+    end
+
+    it 'queries data without error' do
+      stored_datum_expectation
+
+      expect{ subject.issue! }.to_not raise_error
+      expect(subject.results).to be
+      expect(subject.results).to_not be_empty
+      expect(subject.results.columns).to_not be_empty
+    end
+
+    it 'returns an empty collection when not finding data' do
+      expect{ subject_without_data.issue! }.to_not raise_error
+      expect(subject.results).to_not be
+    end
+  end
+
+  describe 'single-key get interface' do
+    subject{ Riak::TimeSeries::Read.new test_client, table_name }
+    it 'retrieves data without error' do
+      stored_datum_expectation
+
+      subject.key = key
+      result = nil
+      expect{ result = subject.read! }.to_not raise_error
+      expect(result).to be
+      expect(result).to_not be_empty
+      expect(result.first).to_not be_empty
+    end
+
+    it 'retrieves data with a null value without error' do
+      stored_datum_null_expectation
+
+      subject.key = key2
+      result = nil
+      expect{ result = subject.read! }.to_not raise_error
+      expect(result).to be
+      expect(result).to_not be_empty
+
+      row = result.first
+      expect(row).to_not be_empty
+      expect(row[4]).to_not be
+    end
+
+    it 'attempts retrieval of non-existent data without error' do
+      subject.key = [ 'foo', 'bar', now ]
+      result = nil
+      expect{ result = subject.read! }.to_not raise_error
+      expect(result).to_not be
+    end
+  end
+
+  describe 'single-key delete interface' do
+    subject{ Riak::TimeSeries::Deletion.new test_client, table_name }
+    let(:test_read){ Riak::TimeSeries::Read.new test_client, table_name }
+
+    it 'deletes data without error' do
+      stored_datum_expectation
+
+      test_read.key = key
+      expect(test_read.read!).to_not be_empty
+
+      subject.key = key
+      expect{ subject.delete! }.to_not raise_error
+
+      expect(test_read.read!).to_not be
+    end
+  end
+
+  describe 'submission interface' do
+    it 'writes data without error' do
+      stored_datum_expectation
+    end
+    it 'writes data with a null value without error' do
+      stored_datum_null_expectation
+    end
+  end
+
+  describe 'list interface' do
+    it 'passes listed keys to a block' do
+      stored_datum_expectation
+      found_expectation = double 'expectation'
+      expect(found_expectation).to receive(:found!).once
+
+      lister = Riak::TimeSeries::List.new test_client, table_name
+
+      lister.issue! do |row|
+        found_expectation.found! if row.to_a == key
+      end
+    end
+
+    it 'returns a list of keys without a block' do
+      stored_datum_expectation
+      found_expectation = double 'expectation'
+
+      lister = Riak::TimeSeries::List.new test_client, table_name
+
+      results = lister.issue!
+
+      expect(results).to include key
+    end
+  end
+end

data/spec/riak/beefcake_protobuffs_backend/object_methods_spec.rb

@@ -8,16 +8,45 @@ describe Riak::Client::BeefcakeProtobuffsBackend::ObjectMethods do
     @backend = Riak::Client::BeefcakeProtobuffsBackend.new(@client, @client.node)
     @bucket = Riak::Bucket.new(@client, "bucket")
     @object = Riak::RObject.new(@bucket, "bar")
+    @content = double(
+      :value => '',
+      :vtag => nil,
+      :content_type => nil,
+      :links => nil,
+      :usermeta => nil,
+      :last_mod => nil,
+      :last_mod_usecs => nil,
+      :indexes => nil,
+      :charset => nil
+    )
   end
 
   describe "loading object data from the response" do
     it "loads the key" do
-      content = double(:value => '', :vtag => nil, :content_type => nil, :links => nil, :usermeta => nil, :last_mod => nil, :indexes => nil, :charset => nil)
-      pbuf = double(:vclock => nil, :content => [content], :value => nil, :key => 'akey')
+      pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
       o = @backend.load_object(pbuf, @object)
       expect(o).to eq(@object)
       expect(o.key).to eq(pbuf.key)
     end
+
+    describe "last_modified" do
+      before :each do
+        allow(@content).to receive(:last_mod) { 1271442363 }
+      end
+
+      it "is set to time of last_mod with microseconds from last_mod_usecs" do
+        allow(@content).to receive(:last_mod_usecs) { 105696 }
+        pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
+        o = @backend.load_object(pbuf, @object)
+        expect(o.last_modified).to eq(Time.at(1271442363, 105696))
+      end
+
+      it "is set to time of last_mod without microseconds if last_mod_usecs is missing" do
+        pbuf = double(:vclock => nil, :content => [@content], :value => nil, :key => 'akey')
+        o = @backend.load_object(pbuf, @object)
+        expect(o.last_modified).to eq(Time.at(1271442363, 0))
+      end
+    end
   end
 
 end

data/spec/riak/beefcake_protobuffs_backend/ts_cell_codec_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'bigdecimal'
+require 'time'
+
+Riak::Client::BeefcakeProtobuffsBackend.configured?
+
+describe Riak::Client::BeefcakeProtobuffsBackend::TsCellCodec do
+  describe 'symmetric serialziation' do
+    it { is_expected.to symmetric_serialize("hello", varchar_value: "hello")}
+    it { is_expected.to symmetric_serialize(5, sint64_value: 5)}
+    it { is_expected.to symmetric_serialize(123.45, double_value: 123.45) }
+    it do
+      is_expected.to symmetric_serialize(Time.parse("June 23, 2015 at 9:46:28 EDT"),
+                                         timestamp_value: 1_435_067_188_000)
+    end
+    it { is_expected.to symmetric_serialize(true, boolean_value: true) }
+    it { is_expected.to symmetric_serialize(false, boolean_value: false) }
+    it { is_expected.to symmetric_serialize(nil, {}) }
+  end
+
+  describe 'serializing values' do
+    it do
+      is_expected.to serialize(BigDecimal.new("0.1"), double_value: 0.1)
+    end
+
+    it 'refuses to serialize big numbers' do
+      expect{ subject.cell_for 2**64 }.
+        to raise_error Riak::TimeSeriesError::SerializeBigIntegerError
+    end
+
+    it 'refuses to serialize complex numbers' do
+      expect{ subject.cell_for(Complex(1, 1)) }.
+        to raise_error Riak::TimeSeriesError::SerializeComplexNumberError
+    end
+
+    it 'refuses to serialize rational numbers' do
+      expect{ subject.cell_for(Rational(1, 1)) }.
+        to raise_error Riak::TimeSeriesError::SerializeRationalNumberError
+    end
+  end
+
+  # deserialization is handled by the symmetric cases above
+  # describe 'deserializing values'
+
+  describe 'with a collection' do
+    let(:not_serialized){ ['hi', 5, 12.34] }
+    let(:serialized) do
+      [
+        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(varchar_value: 'hi'),
+        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(sint64_value: 5),
+        Riak::Client::BeefcakeProtobuffsBackend::TsCell.new(double_value: 12.34)
+      ]
+    end
+
+    it 'serializes' do
+      expect(subject.cells_for(not_serialized)).to eq serialized
+    end
+
+    it 'deserializes' do
+      expect(subject.scalars_for(serialized)).to eq not_serialized
+    end
+  end
+
+  RSpec::Matchers.define :symmetric_serialize do |scalar, cell_options|
+    match do |codec|
+      expect(codec).to(
+        serialize(scalar, cell_options)
+        .and(deserialize(scalar, cell_options)))
+    end
+
+    failure_message do |codec|
+      cell = Riak::Client::BeefcakeProtobuffsBackend::TsCell.new cell_options
+      deserialized = codec.scalar_for cell
+      "expected #{scalar} => #{cell_options} => #{scalar}, got #{scalar} => #{cell.to_hash} => #{deserialized}"
+    end
+
+    description do
+      "serialize #{scalar.class} #{scalar.inspect} to and from TsCell #{cell_options}"
+    end
+  end
+
+  RSpec::Matchers.define :serialize do |measure, options|
+    match do |actual|
+      serialized = actual.cell_for(measure)
+      serialized.to_hash == options
+    end
+
+    failure_message do |actual|
+      serialized = actual.cell_for(measure)
+      "expected #{options}, got #{serialized.to_hash}"
+    end
+
+    description do
+      "serialize #{measure.class} #{measure.inspect} to TsCell #{options}"
+    end
+  end
+
+  RSpec::Matchers.define :deserialize do |expected, options|
+
+    cell = Riak::Client::BeefcakeProtobuffsBackend::TsCell.new options
+
+    match do |codec|
+      deserialized = codec.scalar_for cell
+      deserialized == expected
+    end
+
+    failure_message do |codec|
+      deserialized = codec.scalar_for cell
+      "expected TsCell #{options.inspect} to deserialize to #{expected.class} #{expected.inspect}"
+    end
+
+    description do
+      "deserialize TsCell #{options} to #{expected.class} #{expected.inspect}"
+    end
+  end
+end

data/spec/riak/client_spec.rb

@@ -242,5 +242,16 @@ describe Riak::Client, test_client: true do
       expect(error).not_to be_nil
       expect(error).to be_instance_of(RuntimeError)
     end
+
+    it "logs the error" do
+      expect(Riak.logger).to receive(:warn).with(/Riak::ProtobuffsFailedHeader/).at_least(:once)
+
+      begin
+        @client.backend do |b|
+          raise Riak::ProtobuffsFailedHeader
+        end
+      rescue RuntimeError
+      end
+    end
   end
 end

data/spec/riak/crdt/inner_flag_spec.rb

@@ -21,7 +21,7 @@ describe Riak::Crdt::InnerFlag do
   describe 'updating' do
     let(:new_value){ false }
 
-    it '\asks the class for an update operation' do
+    it 'asks the class for an update operation' do
       operation = described_class.update(new_value)
 
       expect(operation.value).to eq new_value

data/spec/riak/time_series/deletion_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Riak::TimeSeries::Deletion do
+  subject{ described_class.new client, table_name }
+  let(:table_name){ 'GeoCheckin' }
+  let(:client){ instance_double('Riak::Client') }
+  let(:key){ double 'key' }
+  let(:backend) do
+    instance_double('Riak::Client::BeefcakeProtobuffsBackend').tap do |be|
+      allow(client).to receive(:backend).and_yield be
+    end
+  end
+  let(:operator) do
+    Riak::Client::BeefcakeProtobuffsBackend.configured?
+    instance_double(
+      'Riak::Client::BeefcakeProtobuffsBackend::TimeSeriesDeleteOperator'
+    ).tap do |op|
+      allow(backend).to receive(:time_series_delete_operator).
+                         and_return(op)
+    end
+  end
+
+  it 'initializes with client and table name' do
+    expect{ described_class.new client, table_name }.to_not raise_error
+    expect{ described_class.new client }.to raise_error ArgumentError
+  end
+
+  it 'passes keys to delete to a delete operator' do
+    expect{ subject.key = key }.to_not raise_error
+    expect(operator).to receive(:delete).with(table_name, key, Hash.new)
+    expect{ subject.delete! }.to_not raise_error
+  end
+end