aerospike 2.19.0 → 2.26.0

data/lib/aerospike/command/field_type.rb

@@ -21,30 +21,31 @@ module Aerospike
 
   module FieldType
 
-    NAMESPACE = 0
-    TABLE = 1
-    KEY = 2
-    #BIN = 3
-    DIGEST_RIPE = 4
-    #GU_TID = 5
-    DIGEST_RIPE_ARRAY = 6
-    TRAN_ID = 7    # user supplied transaction id, which is simply passed back
-    SCAN_OPTIONS = 8
-    SCAN_TIMEOUT = 9
-    RECORDS_PER_SECOND = 10
-    INDEX_NAME = 21
-    INDEX_RANGE = 22
-    INDEX_FILTER = 23
-    INDEX_LIMIT = 24
-    INDEX_ORDER_BY = 25
-    INDEX_TYPE = 26
-    UDF_PACKAGE_NAME = 30
-    UDF_FUNCTION = 31
-    UDF_ARGLIST = 32
-    UDF_OP = 33
-    QUERY_BINLIST = 40
-    BATCH_INDEX = 41
-    PREDEXP = 43
+    NAMESPACE  = 0
+    TABLE      = 1
+    KEY        = 2
+    DIGEST_RIPE  = 4
+    DIGEST_RIPE_ARRAY     = 6
+    TRAN_ID               = 7 # user supplied transaction id, which is simply passed back
+    SCAN_OPTIONS          = 8
+    SOCKET_TIMEOUT        = 9
+    RECORDS_PER_SECOND    = 10
+    PID_ARRAY             = 11
+    DIGEST_ARRAY          = 12
+    MAX_RECORDS           = 13
+    BVAL_ARRAY            = 15
+    INDEX_NAME            = 21
+    INDEX_RANGE           = 22
+    INDEX_CONTEXT         = 23
+    INDEX_TYPE            = 26
+    UDF_PACKAGE_NAME      = 30
+    UDF_FUNCTION          = 31
+    UDF_ARGLIST           = 32
+    UDF_OP                = 33
+    QUERY_BINLIST         = 40
+    BATCH_INDEX           = 41
+    BATCH_INDEX_WITH_SET  = 42
+    FILTER_EXP            = 43
 
   end # module
 

data/lib/aerospike/command/login_command.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+# Copyright 2014-2020 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/admin_command'
+
+module Aerospike
+
+  private
+
+  attr_reader :session_token, :session_expiration
+
+  class LoginCommand < AdminCommand #:nodoc:
+
+    def login(conn, policy)
+        hashed_pass = LoginCommand.hash_password(policy.password)
+        authenticate(conn, policy, hashed_pass)
+    end
+
+    def authenticate(conn, user, hashed_pass)
+      write_header(LOGIN, 2)
+      write_field_str(USER, policy.user)
+      write_field_bytes(CREDENTIAL, hashed_pass)
+
+      parse_tokens(conn)
+    end
+
+    def authenticate_new(conn, cluster)
+      @data_offset = 8
+      policy = cluster.client_policy
+      case policy.auth_mode
+      when Aerospike::AuthMode::EXTERNAL
+        write_header(LOGIN, 3)
+        write_field_str(USER, policy.user)
+        write_field_bytes(CREDENTIAL, cluster.password)
+        write_field_str(CLEAR_PASSWORD, policy.password)
+      when Aerospike::AuthMode::INTERNAL
+        write_header(LOGIN, 2)
+        write_field_str(USER, policy.user)
+        write_field_bytes(CREDENTIAL, cluster.password)
+      when Aerospike::AuthMode::PKI
+        write_header(LOGIN, 0)
+      else
+        raise Exceptions::Aerospike.new(Aerospike::ResultCode::COMMAND_REJECTED, "Invalid client_policy#auth_mode.")
+      end
+
+      parse_tokens(conn)
+      cluster.session_token = @session_token
+      cluster.session_expiration = @session_expiration
+    end
+
+    def parse_tokens(conn)
+      begin
+        write_size
+        conn.write(@data_buffer, @data_offset)
+        conn.read(@data_buffer, HEADER_SIZE)
+
+        result = @data_buffer.read(RESULT_CODE)
+
+        if result != 0
+          return if result == Aerospike::ResultCode::SECURITY_NOT_ENABLED
+          raise Exceptions::Aerospike.new(result, "Authentication failed")
+        end
+
+        # read the rest of the buffer
+        size = @data_buffer.read_int64(0)
+        receive_size = (size & 0xFFFFFFFFFFFF) - HEADER_REMAINING
+        field_count = @data_buffer.read(11) & 0xFF
+
+        if receive_size <= 0 || receive_size > @data_buffer.size || field_count <= 0
+          raise Exceptions::Aerospike.new(result, "Node failed to retrieve session token")
+        end
+
+        if @data_buffer.size < receive_size
+          @data_buffer.resize(receive_size)
+        end
+
+        conn.read(@data_buffer, receive_size)
+
+        @data_offset = 0
+        for i in 0...field_count
+          mlen = @data_buffer.read_int32(@data_offset)
+          @data_offset += 4
+          id = @data_buffer.read(@data_offset)
+          @data_offset += 1
+          mlen -= 1
+
+          case id
+          when SESSION_TOKEN
+            # copy the contents of the buffer into a new byte slice
+            @session_token = @data_buffer.read(@data_offset, mlen)
+
+          when SESSION_TTL
+            # Subtract 60 seconds from TTL so client session expires before server session.
+            seconds = @data_buffer.read_int32(@data_offset) - 60
+
+            if seconds > 0
+              @session_expiration = Time.now + (seconds/86400)
+            else
+              Aerospike.logger.warn("Invalid session TTL: #{seconds}")
+              raise Exceptions::Aerospike.new(result, "Node failed to retrieve session token")
+            end
+          end
+
+          @data_offset += mlen
+        end
+
+        if !@session_token
+          raise Exceptions::Aerospike.new(result, "Node failed to retrieve session token")
+        end
+      ensure
+        Buffer.put(@data_buffer)
+      end
+    end
+
+    def authenticate_via_token(conn, cluster)
+      @data_offset = 8
+      policy = cluster.client_policy
+      if policy.auth_mode == Aerospike::AuthMode::PKI
+        write_header(AUTHENTICATE, 1)
+      else
+        write_header(AUTHENTICATE, 2)
+        write_field_str(USER, policy.user)
+      end
+
+      write_field_bytes(SESSION_TOKEN, cluster.session_token) if cluster.session_token
+      write_size
+
+      conn.write(@data_buffer, @data_offset)
+      conn.read(@data_buffer, HEADER_SIZE)
+
+      result = @data_buffer.read(RESULT_CODE)
+      size = @data_buffer.read_int64(0)
+      receive_size = (size & 0xFFFFFFFFFFFF) - HEADER_REMAINING
+      conn.read(@data_buffer, receive_size)
+
+      if result != 0
+        return if result == Aerospike::ResultCode::SECURITY_NOT_ENABLED
+        raise Exceptions::Aerospike.new(result, "Authentication failed")
+      end
+
+      nil
+    end
+
+    SALT = '$2a$10$7EqJtq98hPqEX7fNZaFWoO'
+    def self.hash_password(password)
+      # Hashing the password with the cost of 10, with a static salt
+      return BCrypt::Engine.hash_secret(password, SALT, :cost => 10)
+    end
+  end
+end
+

data/lib/aerospike/command/multi_command.rb

@@ -32,6 +32,9 @@ module Aerospike
       @compressed_data_buffer = nil
       @compressed_data_offset = nil
 
+      @node_partitions = nil
+      @tracker = nil
+
       self
     end
 
@@ -97,8 +100,9 @@ module Aerospike
 
         # The only valid server return codes are "ok", "not found" and "filtered out".
         # If other return codes are received, then abort the batch.
-        if result_code != 0 
+        if result_code != 0
             if result_code == Aerospike::ResultCode::KEY_NOT_FOUND_ERROR || result_code == Aerospike::ResultCode::FILTERED_OUT
+              # NOOP
             else
               raise Aerospike::Exceptions::Aerospike.new(result_code)
             end
@@ -142,12 +146,31 @@ module Aerospike
           set_name = @data_buffer.read(1, size).force_encoding('utf-8')
         when Aerospike::FieldType::KEY
           user_key = Aerospike::bytes_to_key_value(@data_buffer.read(1).ord, @data_buffer, 2, size-1)
+        when Aerospike::FieldType::BVAL_ARRAY
+          bval = @data_buffer.read_uint64_little_endian(1)
         end
 
         i = i.succ
       end
 
-      Aerospike::Key.new(namespace, set_name, user_key, digest)
+      Aerospike::Key.new(namespace, set_name, user_key, digest, bval: bval)
+    end
+
+    def skip_key(field_count)
+      # in Stream queries, there are no keys
+      return unless field_count > 0
+
+      i = 0
+      while i < field_count
+        read_bytes(4)
+
+        fieldlen = @data_buffer.read_int32(0)
+        read_bytes(fieldlen)
+
+        i = i.succ
+      end
+
+      nil
     end
 
     # Parses the given byte buffer and populate the result object.

data/lib/aerospike/command/operate_args.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+# Copyright 2016-2020 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/operation"
+
+module Aerospike
+  private
+
+  class OperateArgs
+    attr_reader :write_policy, :operations, :partition
+    attr_reader :size, :read_attr, :write_attr, :has_write
+
+    RESPOND_ALL_OPS_READ_CMDS = [Operation::BIT_READ, Operation::EXP_READ, Operation::HLL_READ, Operation::CDT_READ]
+    READ_CMDS = [Operation::BIT_READ, Operation::EXP_READ, Operation::HLL_READ, Operation::CDT_READ, Operation::CDT_READ, Operation::READ]
+    MODIFY_CMDS = [Operation::BIT_MODIFY, Operation::EXP_MODIFY, Operation::HLL_MODIFY, Operation::CDT_MODIFY]
+
+    def initialize(cluster, policy, write_default, read_default, key, operations)
+      @operations = operations
+
+      data_offset = 0
+      rattr = 0
+      wattr = 0
+      write = false
+      read_bin = false
+      read_header = false
+      respond_all_ops = false
+
+      @operations.each do |operation|
+        if READ_CMDS.include?(operation.op_type)
+          if RESPOND_ALL_OPS_READ_CMDS.include?(operation.op_type)
+            # Map @operations require respond_all_ops to be true.
+            respond_all_ops = true
+          end
+
+          rattr |= Aerospike::INFO1_READ
+
+          # Read all bins if no bin is specified.
+          rattr |= Aerospike::INFO1_GET_ALL if operation.bin_name.nil?
+          read_bin = true
+        elsif operation.op_type == Operation::READ_HEADER
+          rattr |= Aerospike::INFO1_READ
+          read_header = true
+        elsif MODIFY_CMDS.include?(operation.op_type)
+          # Map @operations require respond_all_ops to be true.
+          respond_all_ops = true
+
+          wattr = Aerospike::INFO2_WRITE
+          write = true
+        else
+          wattr = Aerospike::INFO2_WRITE
+          write = true
+        end
+        data_offset += operation.bin_name.bytesize + Aerospike::OPERATION_HEADER_SIZE unless operation.bin_name.nil?
+        data_offset += operation.bin_value.estimate_size
+      end
+
+      @size = data_offset
+      @has_write = write
+
+      if read_header && !read_bin
+        rattr |= Aerospike::INFO1_NOBINDATA
+      end
+      @read_attr = rattr
+
+      if policy.nil?
+        @write_policy = write ? write_default : read_default
+      else
+        @write_policy = policy
+      end
+
+      # When GET_ALL is specified, RESPOND_ALL_OPS must be disabled.
+      if (respond_all_ops && policy.record_bin_multiplicity) && (rattr & Aerospike::INFO1_GET_ALL) == 0
+        wattr |= Aerospike::INFO2_RESPOND_ALL_OPS
+      end
+      @write_attr = wattr
+
+      if write
+        # @partition = Partition.write(cluster, @write_policy, key)
+        @partition = Partition.new_by_key(key)
+      else
+        # @partition = Partition.read(cluster, @write_policy, key)
+        @partition = Partition.new_by_key(key)
+      end
+    end
+  end
+end

data/lib/aerospike/command/operate_command.rb

@@ -14,33 +14,28 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'aerospike/command/read_command'
+require "aerospike/command/read_command"
 
 module Aerospike
-
   private
 
   class OperateCommand < ReadCommand #:nodoc:
+    def initialize(cluster, key, args)
+      super(cluster, args.write_policy, key, nil)
 
-    def initialize(cluster, policy, key, operations)
-      super(cluster, policy, key, nil)
-
-      @operations = operations
+      @args = args
     end
 
     def get_node
       @cluster.master_node(@partition)
     end
 
-
     def write_bins
-      @operations.select{|op| op.op_type == Aerospike::Operation::WRITE}.map(&:bin).compact
+      @operations.select { |op| op.op_type == Aerospike::Operation::WRITE }.map(&:bin).compact
     end
 
     def write_buffer
-      set_operate(@policy, @key, @operations)
+      set_operate(@args.write_policy, @key, @args)
     end
-
   end # class
-
 end # module

data/lib/aerospike/command/read_command.rb

@@ -98,7 +98,7 @@ module Aerospike
       receive_size = (sz & 0xFFFFFFFFFFFF) - header_length
 
       # Read remaining message bytes.
-      if compressed_sz 
+      if compressed_sz
         @data_buffer.eat!(MSG_TOTAL_HEADER_SIZE)
       elsif receive_size > 0
         size_buffer_sz(receive_size)
@@ -117,7 +117,7 @@ module Aerospike
           @record = Record.new(@node, @key, nil, generation, expiration)
           return
         end
-  
+
         @record = parse_record(op_count, field_count, generation, expiration)
         return
       end

data/lib/aerospike/connection/authenticate.rb

@@ -21,9 +21,41 @@ module Aerospike
   module Connection # :nodoc:
     module Authenticate
       class << self
-        def call(conn, user, password)
-          command = AdminCommand.new
-          command.authenticate(conn, user, password)
+        def call(conn, user, hashed_pass)
+          command = LoginCommand.new
+          command.authenticate(conn, user, hashed_pass)
+          true
+        rescue ::Aerospike::Exceptions::Aerospike
+          conn.close if conn
+          raise ::Aerospike::Exceptions::InvalidCredentials
+        end
+      end
+    end
+    module AuthenticateNew
+      class << self
+        INVALID_SESSION_ERR = [ResultCode::INVALID_CREDENTIAL,
+          ResultCode::EXPIRED_SESSION]
+
+        def call(conn, cluster)
+          command = LoginCommand.new
+          if cluster.session_valid?
+            begin
+              command.authenticate_via_token(conn, cluster)
+            rescue => ae
+              # always reset session info on errors to be on the safe side
+              cluster.reset_session_info
+              if ae.is_a?(Exceptions::Aerospike)
+                if INVALID_SESSION_ERR.include?(ae.result_code)
+                  command.authenticate_new(conn, cluster)
+                  return true
+                end
+              end
+              raise ae
+            end
+          else
+            command.authenticate_new(conn, cluster)
+          end
+
           true
         rescue ::Aerospike::Exceptions::Aerospike
           conn.close if conn
@@ -33,3 +65,4 @@ module Aerospike
     end
   end
 end
+