aerospike 2.29.0 → 4.0.0

data/lib/aerospike/cluster.rb

@@ -120,15 +120,15 @@ module Aerospike
     # Returns a node on the cluster for read operations
     def batch_read_node(partition, replica_policy)
       case replica_policy
-        when Aerospike::Replica::MASTER, Aerospike::Replica::SEQUENCE
-          return master_node(partition)
-        when Aerospike::Replica::MASTER_PROLES
-          return master_proles_node(partition)
-        when Aerospike::Replica::PREFER_RACK
-          return rack_node(partition, seq)
-        when Aerospike::Replica::RANDOM
-          return random_node
-        else
+      when Aerospike::Replica::MASTER, Aerospike::Replica::SEQUENCE
+          master_node(partition)
+      when Aerospike::Replica::MASTER_PROLES
+          master_proles_node(partition)
+      when Aerospike::Replica::PREFER_RACK
+          rack_node(partition, seq)
+      when Aerospike::Replica::RANDOM
+          random_node
+      else
           raise Aerospike::Exceptions::InvalidNode("invalid policy.replica value")
       end
     end
@@ -136,17 +136,17 @@ module Aerospike
     # Returns a node on the cluster for read operations
     def read_node(partition, replica_policy, seq)
       case replica_policy
-        when Aerospike::Replica::MASTER
-          return master_node(partition)
-        when Aerospike::Replica::MASTER_PROLES
-          return master_proles_node(partition)
-        when Aerospike::Replica::PREFER_RACK
-          return rack_node(partition, seq)
-        when Aerospike::Replica::SEQUENCE
-          return sequence_node(partition, seq)
-        when Aerospike::Replica::RANDOM
-          return random_node
-        else
+      when Aerospike::Replica::MASTER
+          master_node(partition)
+      when Aerospike::Replica::MASTER_PROLES
+          master_proles_node(partition)
+      when Aerospike::Replica::PREFER_RACK
+          rack_node(partition, seq)
+      when Aerospike::Replica::SEQUENCE
+          sequence_node(partition, seq)
+      when Aerospike::Replica::RANDOM
+          random_node
+      else
           raise Aerospike::Exceptions::InvalidNode("invalid policy.replica value")
       end
     end
@@ -155,12 +155,12 @@ module Aerospike
     def master_node(partition)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
-      node_array = (replica_array.get)[0]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !node_array
+      node_array = replica_array.get[0]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless node_array
 
-      node = (node_array.get)[partition.partition_id]
+      node = node_array.get[partition.partition_id]
       raise Aerospike::Exceptions::InvalidNode if !node || !node.active?
 
       node
@@ -170,7 +170,7 @@ module Aerospike
     def rack_node(partition, seq)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
@@ -179,10 +179,10 @@ module Aerospike
       node = nil
       fallback = nil
       for i in 1..replica_array.length
-        idx = (seq.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (seq.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
-        next if !node
+        next unless node
 
         fallback = node
 
@@ -202,14 +202,14 @@ module Aerospike
     def master_proles_node(partition)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
       node = nil
       for replica in replica_array
-        idx = (@replica_index.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (@replica_index.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
         return node if node && node.active?
       end
@@ -221,14 +221,14 @@ module Aerospike
     def sequence_node(partition, seq)
       partition_map = partitions
       replica_array = partition_map[partition.namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
       replica_array = replica_array.get
 
       node = nil
       for replica in replica_array
-        idx = (seq.update{|v| v.succ} % replica_array.size).abs
-        node = (replica_array[idx].get)[partition.partition_id]
+        idx = (seq.update { |v| v.succ } % replica_array.size).abs
+        node = replica_array[idx].get[partition.partition_id]
 
         return node if node && node.active?
       end
@@ -236,9 +236,13 @@ module Aerospike
       raise Aerospike::Exceptions::InvalidNode
     end
 
-    def get_node_for_key(replica_policy, key)
+    def get_node_for_key(replica_policy, key, is_write: false)
       partition = Partition.new_by_key(key)
-      batch_read_node(partition, replica_policy)
+      if is_write
+        master_node(partition)
+      else
+        batch_read_node(partition, replica_policy)
+      end
     end
 
     # Returns partitions pertaining to a node
@@ -247,10 +251,10 @@ module Aerospike
 
       partition_map = partitions
       replica_array = partition_map[namespace]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless replica_array
 
-      node_array = (replica_array.get)[0]
-      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !node_array
+      node_array = replica_array.get[0]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") unless node_array
 
 
       pid = 0
@@ -270,7 +274,7 @@ module Aerospike
       i = 0
       while i < length
         # Must handle concurrency with other non-tending threads, so node_index is consistent.
-        idx = (@node_index.update{ |v| v.succ } % node_array.length).abs
+        idx = (@node_index.update { |v| v.succ } % node_array.length).abs
         node = node_array[idx]
 
         return node if node.active?
@@ -366,13 +370,13 @@ module Aerospike
       @tend_thread = Thread.new do
         Thread.current.abort_on_exception = false
         loop do
-          begin
+
             tend
             sleep(@tend_interval / 1000.0)
-          rescue => e
+        rescue => e
             Aerospike.logger.error("Exception occured during tend: #{e}")
             Aerospike.logger.debug { e.backtrace.join("\n") }
-          end
+
         end
       end
     end
@@ -453,7 +457,7 @@ module Aerospike
 
     def log_tend_stats(nodes)
       diff = nodes.size - @old_node_count
-      action = "#{diff.abs} #{diff.abs == 1 ? "node has" : "nodes have"} #{diff > 0 ? "joined" : "left"} the cluster."
+      action = "#{diff.abs} #{diff.abs == 1 ? 'node has' : 'nodes have'} #{diff > 0 ? 'joined' : 'left'} the cluster."
       Aerospike.logger.info("Tend finished. #{action} Old node count: #{@old_node_count}, New node count: #{nodes.size}")
       @old_node_count = nodes.size
     end
@@ -689,11 +693,11 @@ module Aerospike
     end
 
     def node_exists(search, node_list)
-      node_list.any? {|node| node == search }
+      node_list.any? { |node| node == search }
     end
 
     def find_node_by_name(node_name)
-      nodes.detect{|node| node.name == node_name }
+      nodes.detect { |node| node.name == node_name }
     end
   end
 end

data/lib/aerospike/command/batch_index_command.rb

@@ -21,11 +21,7 @@ module Aerospike
 
   class BatchIndexCommand < MultiCommand #:nodoc:
 
-    attr_accessor :batch
-    attr_accessor :policy
-    attr_accessor :bin_names
-    attr_accessor :results
-    attr_accessor :read_attr
+    attr_accessor :batch, :policy, :bin_names, :results, :read_attr
 
     def initialize(node, batch, policy, bin_names, results, read_attr)
       super(node)
@@ -42,8 +38,8 @@ module Aerospike
       field_count_row = 1
       field_count = 1
 
-      predexp_size = estimate_predexp(@policy.predexp)
-      field_count += 1 if predexp_size > 0
+      exp_size = estimate_expression_size(@policy.filter_exp)
+      field_count += 1 if exp_size > 0
 
       if bin_names
         bin_names.each do |bin_name|
@@ -58,7 +54,7 @@ module Aerospike
       batch.keys.each do |key|
         @data_offset += key.digest.length + 4 # 4 byte batch offset
 
-        if prev != nil && prev.namespace == key.namespace
+        if !prev.nil? && prev.namespace == key.namespace
           @data_offset += 1
         else
           @data_offset += key.namespace.bytesize + FIELD_HEADER_SIZE + 1 + 1 + 2 + 2 # repeat/no-repeat flag + read_attr flags + field_count + operation_count
@@ -66,9 +62,9 @@ module Aerospike
         end
       end
       size_buffer
-      write_header(policy,read_attr | INFO1_BATCH, 0, field_count, 0)
+      write_header_read(policy, read_attr | INFO1_BATCH, 0, field_count, 0)
 
-      write_predexp(@policy.predexp, predexp_size)
+      write_filter_exp(@policy.filter_exp, exp_size)
 
       write_field_header(0, Aerospike::FieldType::BATCH_INDEX)
       @data_offset += @data_buffer.write_int32(batch.keys.length, @data_offset)
@@ -80,7 +76,7 @@ module Aerospike
         @data_offset += @data_buffer.write_int32(index, @data_offset)
         @data_offset += @data_buffer.write_binary(key.digest, @data_offset)
 
-        if (prev != nil && prev.namespace == key.namespace)
+        if !prev.nil? && prev.namespace == key.namespace
           @data_offset += @data_buffer.write_byte(1, @data_offset)
         else
           @data_offset += @data_buffer.write_byte(0, @data_offset)

data/lib/aerospike/command/batch_index_node.rb

@@ -19,13 +19,12 @@ module Aerospike
 
   class BatchIndexNode #:nodoc:
 
-    attr_accessor :node
-    attr_accessor :keys_by_idx
+    attr_accessor :node, :keys_by_idx
 
     def self.generate_list(cluster, replica_policy, keys)
       keys.each_with_index
-        .group_by { |key, _| cluster.get_node_for_key(replica_policy, key) }
-        .map { |node, keys_with_idx| BatchIndexNode.new(node, keys_with_idx) }
+          .group_by { |key, _| cluster.get_node_for_key(replica_policy, key) }
+          .map { |node, keys_with_idx| BatchIndexNode.new(node, keys_with_idx) }
     end
 
     def initialize(node, keys_with_idx)

data/lib/aerospike/command/batch_operate_command.rb

@@ -0,0 +1,151 @@
+# Copyright 2018 Aerospike, Inc.
+#
+# Portions may be licensed to Aerospike, Inc. under one or more contributor
+# license agreements.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'aerospike/command/multi_command'
+
+module Aerospike
+
+  class BatchOperateCommand < MultiCommand #:nodoc:
+
+    attr_accessor :batch, :policy, :attr, :records
+
+    def initialize(node, batch, policy, records)
+      super(node)
+      @batch = batch
+      @policy = policy
+      @records = records
+    end
+
+    def batch_flags
+      flags = 0
+      # flags |= 0x1 if @policy.allow_inline
+      flags |= 0x2 if @policy.allow_inline_ssd
+      flags |= 0x4 if @policy.respond_all_keys
+      flags
+    end
+
+    def write_buffer
+      field_count = 1
+
+      exp_size = estimate_expression_size(@policy.filter_exp)
+      @data_offset += exp_size
+      field_count += 1 if exp_size > 0
+
+      @data_buffer.reset
+      begin_cmd
+      @data_offset += FIELD_HEADER_SIZE + 4 + 1 # batch.keys.length + flags
+
+      prev = nil
+      @records.each do |record|
+        key = record.key
+        @data_offset += key.digest.length + 4 # 4 byte batch offset
+
+        if !@policy.send_key && !prev.nil? && prev.key.namespace == key.namespace && prev.key.set_name == key.set_name && record == prev
+          @data_offset += 1
+        else
+          @data_offset += 12
+          @data_offset += key.namespace.bytesize + FIELD_HEADER_SIZE
+          @data_offset += key.set_name.bytesize + FIELD_HEADER_SIZE
+          @data_offset += record.size
+        end
+
+        prev = record
+      end
+      size_buffer
+      write_batch_header(policy, field_count)
+
+      write_filter_exp(@policy.filter_exp, exp_size)
+
+      field_size_offset = @data_offset
+
+      write_field_header(0, Aerospike::FieldType::BATCH_INDEX)
+      @data_offset += @data_buffer.write_int32(batch.records.length, @data_offset)
+      @data_offset += @data_buffer.write_byte(batch_flags, @data_offset)
+
+      prev = nil
+      attr = BatchAttr.new
+      batch.records.each_with_index do |record, index|
+        @data_offset += @data_buffer.write_int32(index, @data_offset)
+        key = record.key
+        @data_offset += @data_buffer.write_binary(key.digest, @data_offset)
+
+        if !@policy.send_key && !prev.nil? && prev.key.namespace == key.namespace && prev.key.set_name == key.set_name && record == prev
+          @data_offset += @data_buffer.write_byte(BATCH_MSG_REPEAT, @data_offset)
+        else
+          case record
+          when BatchRead
+            attr.set_batch_read(record.policy)
+            if record.bin_names&.length&.> 0
+              write_batch_bin_names(key, record.bin_names, attr, attr.filter_exp)
+            elsif record.ops&.length&.> 0
+              attr.adjust_read(br.ops)
+              write_batch_operations(key, record.ops, attr, attr.filter_exp)
+            else
+              attr.adjust_read_all_bins(record.read_all_bins)
+              write_batch_read(key, attr, attr.filter_exp, 0)
+            end
+
+          when BatchWrite
+            attr.set_batch_write(record.policy)
+            attr.adjust_write(record.ops)
+            write_batch_operations(key, record.ops, attr, attr.filter_exp)
+
+          when BatchUDF
+            attr.set_batch_udf(record.policy)
+            write_batch_write(key, attr, attr.filter_exp, 3, 0)
+            write_field_string(record.package_name, Aerospike::FieldType::UDF_PACKAGE_NAME)
+            write_field_string(record.function_name, Aerospike::FieldType::UDF_FUNCTION)
+            write_field_bytes(record.arg_bytes, Aerospike::FieldType::UDF_ARGLIST)
+
+          when BatchDelete
+            attr.set_batch_delete(record.policy)
+            write_batch_write(key, attr, attr.filter_exp, 0, 0)
+          end
+
+          prev = record
+        end
+      end
+
+      @data_buffer.write_uint32(@data_offset-MSG_TOTAL_HEADER_SIZE-4, field_size_offset)
+
+      end_cmd
+      mark_compressed(@policy)
+    end
+
+    # Parse all results in the batch.  Add records to shared list.
+    # If the record was not found, the bins will be nil.
+    def parse_row(result_code)
+      generation = @data_buffer.read_int32(6)
+      expiration = @data_buffer.read_int32(10)
+      batch_index = @data_buffer.read_int32(14)
+      field_count = @data_buffer.read_int16(18)
+      op_count = @data_buffer.read_int16(20)
+
+      skip_key(field_count)
+      req_key = records[batch_index].key
+
+      records[batch_index].result_code = result_code
+      case result_code
+      when 0, ResultCode::UDF_BAD_RESPONSE
+        record = parse_record(req_key, op_count, generation, expiration)
+        records[batch_index].record = record
+      end
+    end
+
+  end # class
+
+end # module

data/lib/aerospike/command/batch_operate_node.rb

@@ -0,0 +1,51 @@
+# Copyright 2018 Aerospike, Inc.
+#
+# Portions may be licensed to Aerospike, Inc. under one or more contributor
+# license agreements.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Aerospike
+
+  class BatchOperateNode #:nodoc:
+
+    attr_accessor :node, :records_by_idx
+
+    def self.generate_list(cluster, replica_policy, records)
+      records.each_with_index
+             .group_by { |record, _| cluster.get_node_for_key(replica_policy, record.key, is_write: record.has_write) }
+             .map { |node, records_with_idx| BatchOperateNode.new(node, records_with_idx) }
+    end
+
+    def initialize(node, records_with_idx)
+      @node = node
+      @records_by_idx = records_with_idx.map(&:reverse).to_h
+    end
+
+    def records
+      records_by_idx.values
+    end
+
+    def each_record_with_index
+      records_by_idx.each do |idx, rec|
+        yield rec, idx
+      end
+    end
+
+    def record_for_index(idx)
+      @records_by_idx[idx]
+    end
+
+  end
+
+end