aerospike 2.19.0 → 2.26.0

data/lib/aerospike/client.rb

@@ -15,8 +15,8 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'digest'
-require 'base64'
+require "digest"
+require "base64"
 
 module Aerospike
 
@@ -36,7 +36,6 @@ module Aerospike
   # +:fail_if_not_connected+ set to true
 
   class Client
-
     attr_accessor :default_admin_policy
     attr_accessor :default_batch_policy
     attr_accessor :default_info_policy
@@ -48,8 +47,7 @@ module Aerospike
     attr_accessor :cluster
 
     def initialize(hosts = nil, policy: ClientPolicy.new, connect: true)
-
-      hosts = ::Aerospike::Host::Parse.(hosts || ENV['AEROSPIKE_HOSTS'] || 'localhost')
+      hosts = ::Aerospike::Host::Parse.(hosts || ENV["AEROSPIKE_HOSTS"] || "localhost")
       policy = create_policy(policy, ClientPolicy)
       set_default_policies(policy.policies)
       @cluster = Cluster.new(policy, hosts)
@@ -249,7 +247,7 @@ module Aerospike
       end
 
       response = send_info_command(policy, str_cmd, node).upcase
-      return if response == 'OK'
+      return if response == "OK"
       raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_ERROR, "Truncate failed: #{response}")
     end
 
@@ -386,7 +384,8 @@ module Aerospike
     def operate(key, operations, options = nil)
       policy = create_policy(options, OperatePolicy, default_operate_policy)
 
-      command = OperateCommand.new(@cluster, policy, key, operations)
+      args = OperateArgs.new(cluster, policy, default_write_policy, default_operate_policy, key, operations)
+      command = OperateCommand.new(@cluster, key, args)
       execute_command(command)
       command.record
     end
@@ -415,7 +414,7 @@ module Aerospike
     def register_udf(udf_body, server_path, language, options = nil)
       policy = create_policy(options, Policy, default_info_policy)
 
-      content = Base64.strict_encode64(udf_body).force_encoding('binary')
+      content = Base64.strict_encode64(udf_body).force_encoding("binary")
       str_cmd = "udf-put:filename=#{server_path};content=#{content};"
       str_cmd << "content-len=#{content.length};udf-type=#{language};"
 
@@ -424,15 +423,15 @@ module Aerospike
 
       res = {}
       response_map.each do |k, response|
-        vals = response.to_s.split(';')
+        vals = response.to_s.split(";")
         vals.each do |pair|
           k, v = pair.split("=", 2)
           res[k] = v
         end
       end
 
-      if res['error']
-        raise Aerospike::Exceptions::CommandRejected.new("Registration failed: #{res['error']}\nFile: #{res['file']}\nLine: #{res['line']}\nMessage: #{res['message']}")
+      if res["error"]
+        raise Aerospike::Exceptions::CommandRejected.new("Registration failed: #{res["error"]}\nFile: #{res["file"]}\nLine: #{res["line"]}\nMessage: #{res["message"]}")
       end
 
       UdfRegisterTask.new(@cluster, server_path)
@@ -454,7 +453,7 @@ module Aerospike
       response_map = @cluster.request_info(policy, str_cmd)
       _, response = response_map.first
 
-      if response == 'ok'
+      if response == "ok"
         UdfRemoveTask.new(@cluster, udf_name)
       else
         raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_ERROR, response)
@@ -466,27 +465,27 @@ module Aerospike
     def list_udf(options = nil)
       policy = create_policy(options, Policy, default_info_policy)
 
-      str_cmd = 'udf-list'
+      str_cmd = "udf-list"
 
       # Send command to one node. That node will distribute it to other nodes.
       response_map = @cluster.request_info(policy, str_cmd)
       _, response = response_map.first
 
-      vals = response.split(';')
+      vals = response.split(";")
 
       vals.map do |udf_info|
-        next if udf_info.strip! == ''
+        next if udf_info.strip! == ""
 
-        udf_parts = udf_info.split(',')
+        udf_parts = udf_info.split(",")
         udf = UDF.new
         udf_parts.each do |values|
-          k, v = values.split('=', 2)
+          k, v = values.split("=", 2)
           case k
-          when 'filename'
+          when "filename"
             udf.filename = v
-          when 'hash'
+          when "hash"
             udf.hash = v
-          when 'type'
+          when "type"
             udf.language = v
           end
         end
@@ -501,7 +500,7 @@ module Aerospike
     #  udf file = <server udf dir>/<package name>.lua
     #
     #  This method is only supported by Aerospike 3 servers.
-    def execute_udf(key, package_name, function_name, args=[], options = nil)
+    def execute_udf(key, package_name, function_name, args = [], options = nil)
       policy = create_policy(options, WritePolicy, default_write_policy)
 
       command = ExecuteCommand.new(@cluster, policy, key, package_name, function_name, args)
@@ -514,10 +513,10 @@ module Aerospike
       result_map = record.bins
 
       # User defined functions don't have to return a value.
-      key, obj = result_map.detect{ |k, _| k.include?('SUCCESS') }
+      key, obj = result_map.detect { |k, _| k.include?("SUCCESS") }
       return obj if key
 
-      key, obj = result_map.detect{ |k, _| k.include?('FAILURE') }
+      key, obj = result_map.detect { |k, _| k.include?("FAILURE") }
       message = key ? obj.to_s : "Invalid UDF return value"
       raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::UDF_BAD_RESPONSE, message)
     end
@@ -530,7 +529,7 @@ module Aerospike
     #
     # This method is only supported by Aerospike 3 servers.
     # If the policy is nil, the default relevant policy will be used.
-    def execute_udf_on_query(statement, package_name, function_name, function_args=[], options = nil)
+    def execute_udf_on_query(statement, package_name, function_name, function_args = [], options = nil)
       policy = create_policy(options, QueryPolicy, default_query_policy)
 
       nodes = @cluster.nodes
@@ -543,10 +542,11 @@ module Aerospike
 
       # Use a thread per node
       nodes.each do |node|
+        partitions = node.cluster.node_partitions(node, statement.namespace)
         Thread.new do
           Thread.current.abort_on_exception = true
           begin
-            command = QueryCommand.new(node, policy, statement, nil)
+            command = QueryCommand.new(node, policy, statement, nil, partitions)
             execute_command(command)
           rescue => e
             Aerospike.logger.error(e)
@@ -558,7 +558,6 @@ module Aerospike
       ExecuteTask.new(@cluster, statement)
     end
 
-
     #  Create secondary index.
     #  This asynchronous server call will return before command is complete.
     #  The user can optionally wait for command completion by using the returned
@@ -567,7 +566,8 @@ module Aerospike
     #  This method is only supported by Aerospike 3 servers.
     #  index_type should be :string, :numeric or :geo2dsphere (requires server version 3.7 or later)
     #  collection_type should be :list, :mapkeys or :mapvalues
-    def create_index(namespace, set_name, index_name, bin_name, index_type, collection_type = nil, options = nil)
+    #  ctx is an optional list of context. Supported on server v6.1+.
+    def create_index(namespace, set_name, index_name, bin_name, index_type, collection_type = nil, options = nil, ctx: nil)
       if options.nil? && collection_type.is_a?(Hash)
         options, collection_type = collection_type, nil
       end
@@ -576,18 +576,19 @@ module Aerospike
       str_cmd = "sindex-create:ns=#{namespace}"
       str_cmd << ";set=#{set_name}" unless set_name.to_s.strip.empty?
       str_cmd << ";indexname=#{index_name};numbins=1"
+      str_cmd << ";context=#{CDT::Context.base64(ctx)}" unless ctx.to_a.empty?
       str_cmd << ";indextype=#{collection_type.to_s.upcase}" if collection_type
       str_cmd << ";indexdata=#{bin_name},#{index_type.to_s.upcase}"
       str_cmd << ";priority=normal"
 
       # Send index command to one node. That node will distribute the command to other nodes.
       response = send_info_command(policy, str_cmd).upcase
-      if response == 'OK'
+      if response == "OK"
         # Return task that could optionally be polled for completion.
         return IndexTask.new(@cluster, namespace, index_name)
       end
 
-      if response.start_with?('FAIL:200')
+      if response.start_with?("FAIL:200")
         # Index has already been created.  Do not need to poll for completion.
         return IndexTask.new(@cluster, namespace, index_name, true)
       end
@@ -606,10 +607,10 @@ module Aerospike
 
       # Send index command to one node. That node will distribute the command to other nodes.
       response = send_info_command(policy, str_cmd).upcase
-      return if response == 'OK'
+      return if response == "OK"
 
       # Index did not previously exist. Return without error.
-      return if response.start_with?('FAIL:201')
+      return if response.start_with?("FAIL:201")
 
       raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::INDEX_GENERIC, "Drop index failed: #{response}")
     end
@@ -623,13 +624,15 @@ module Aerospike
     # Scan Operations
     #-------------------------------------------------------
 
-    def scan_all(namespace, set_name, bin_names = nil, options = nil)
+    # Reads records in specified namespace and set using partition filter.
+    # If the policy's concurrent_nodes is specified, each server node will be read in
+    # parallel. Otherwise, server nodes are read sequentially.
+    # If partition_filter is nil, all partitions will be scanned.
+    # If the policy is nil, the default relevant policy will be used.
+    # This method is only supported by Aerospike 4.9+ servers.
+    def scan_partitions(partition_filter, namespace, set_name, bin_names = nil, options = nil)
       policy = create_policy(options, ScanPolicy, default_scan_policy)
 
-      # wait until all migrations are finished
-      # TODO: implement
-      # @cluster.WaitUntillMigrationIsFinished(policy.timeout)
-
       # Retry policy must be one-shot for scans.
       # copy on write for policy
       new_policy = policy.clone
@@ -639,118 +642,95 @@ module Aerospike
         raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty.")
       end
 
-      recordset = Recordset.new(policy.record_queue_size, nodes.length, :scan)
-
-      if policy.concurrent_nodes
-        # Use a thread per node
-        nodes.each do |node|
-          Thread.new do
-            Thread.current.abort_on_exception = true
-            command = ScanCommand.new(node, new_policy, namespace, set_name, bin_names, recordset)
-            begin
-              execute_command(command)
-            rescue => e
-              Aerospike.logger.error(e.backtrace.join("\n")) unless e == SCAN_TERMINATED_EXCEPTION
-              recordset.cancel(e)
-            ensure
-              recordset.thread_finished
-            end
-          end
-        end
-      else
-        Thread.new do
-          Thread.current.abort_on_exception = true
-          nodes.each do |node|
-            command = ScanCommand.new(node, new_policy, namespace, set_name, bin_names, recordset)
-            begin
-              execute_command(command)
-            rescue => e
-              Aerospike.logger.error(e.backtrace.join("\n")) unless e == SCAN_TERMINATED_EXCEPTION
-              recordset.cancel(e)
-            ensure
-              recordset.thread_finished
-            end
-          end
-        end
+      tracker = Aerospike::PartitionTracker.new(policy, nodes, partition_filter)
+      recordset = Recordset.new(policy.record_queue_size, 1, :scan)
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        ScanExecutor.scan_partitions(policy, @cluster, tracker, namespace, set_name, recordset, bin_names)
       end
 
       recordset
     end
 
-    # ScanNode reads all records in specified namespace and set, from one node only.
-    # The policy can be used to specify timeouts.
-    def scan_node(node, namespace, set_name, bin_names = nil, options = nil)
+    # Reads all records in specified namespace and set for one node only.
+    # If the policy is nil, the default relevant policy will be used.
+    def scan_node_partitions(node, namespace, set_name, bin_names = nil, options = nil)
       policy = create_policy(options, ScanPolicy, default_scan_policy)
-      # wait until all migrations are finished
-      # TODO: implement
-      # @cluster.WaitUntillMigrationIsFinished(policy.timeout)
 
       # Retry policy must be one-shot for scans.
       # copy on write for policy
       new_policy = policy.clone
-      new_policy.max_retries = 0
 
-      node = @cluster.get_node_by_name(node) unless node.is_a?(Aerospike::Node)
+      unless node.active?
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty.")
+      end
 
+      tracker = Aerospike::PartitionTracker.new(policy, [node])
       recordset = Recordset.new(policy.record_queue_size, 1, :scan)
-
       Thread.new do
         Thread.current.abort_on_exception = true
-        command = ScanCommand.new(node, new_policy, namespace, set_name, bin_names, recordset)
-        begin
-          execute_command(command)
-        rescue => e
-          Aerospike.logger.error(e.backtrace.join("\n")) unless e == SCAN_TERMINATED_EXCEPTION
-          recordset.cancel(e)
-        ensure
-          recordset.thread_finished
-        end
+        ScanExecutor.scan_partitions(policy, @cluster, tracker, namespace, set_name, recordset, bin_names)
       end
 
       recordset
     end
 
+    # Reads all records in specified namespace and set from all nodes.
+    # If the policy's concurrent_nodes is specified, each server node will be read in
+    # parallel. Otherwise, server nodes are read sequentially.
+    # If the policy is nil, the default relevant policy will be used.
+    def scan_all(namespace, set_name, bin_names = nil, options = nil)
+      scan_partitions(Aerospike::PartitionFilter.all, namespace, set_name, bin_names, options)
+    end
+
+    # ScanNode reads all records in specified namespace and set, from one node only.
+    # The policy can be used to specify timeouts.
+    def scan_node(node, namespace, set_name, bin_names = nil, options = nil)
+      scan_node_partitions(node, namespace, set_name, bin_names, options)
+    end
+
     #--------------------------------------------------------
     # Query functions (Supported by Aerospike 3 servers only)
     #--------------------------------------------------------
 
-    # Query executes a query and returns a recordset.
-    # The query executor puts records on a channel from separate goroutines.
-    # The caller can concurrently pops records off the channel through the
-    # record channel.
+    # Executes a query for specified partitions and returns a recordset.
+    # The query executor puts records on the queue from separate threads.
+    # The caller can concurrently pop records off the queue through the
+    # recordset.records API.
     #
-    # This method is only supported by Aerospike 3 servers.
-    # If the policy is nil, a default policy will be generated.
-    def query(statement, options = nil)
+    # This method is only supported by Aerospike 4.9+ servers.
+    # If the policy is nil, the default relevant policy will be used.
+    def query_partitions(partition_filter, statement, options = nil)
       policy = create_policy(options, QueryPolicy, default_query_policy)
       new_policy = policy.clone
 
       nodes = @cluster.nodes
       if nodes.empty?
-        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Scan failed because cluster is empty.")
+        raise Aerospike::Exceptions::Aerospike.new(Aerospike::ResultCode::SERVER_NOT_AVAILABLE, "Query failed because cluster is empty.")
       end
 
-      recordset = Recordset.new(policy.record_queue_size, nodes.length, :query)
-
-      # Use a thread per node
-      nodes.each do |node|
-        Thread.new do
-          Thread.current.abort_on_exception = true
-          command = QueryCommand.new(node, new_policy, statement, recordset)
-          begin
-            execute_command(command)
-          rescue => e
-            Aerospike.logger.error(e.backtrace.join("\n")) unless e == QUERY_TERMINATED_EXCEPTION
-            recordset.cancel(e)
-          ensure
-            recordset.thread_finished
-          end
-        end
+      # result recordset
+      recordset = Recordset.new(policy.record_queue_size, 1, :query)
+      tracker = PartitionTracker.new(policy, nodes, partition_filter)
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        QueryExecutor.query_partitions(@cluster, policy, tracker, statement, recordset)
       end
 
       recordset
     end
 
+    # Query executes a query and returns a recordset.
+    # The query executor puts records on a channel from separate threads.
+    # The caller can concurrently pops records off the channel through the
+    # record channel.
+    #
+    # This method is only supported by Aerospike 3 servers.
+    # If the policy is nil, a default policy will be generated.
+    def query(statement, options = nil)
+      query_partitions(Aerospike::PartitionFilter.all, statement, options)
+    end
+
     #-------------------------------------------------------
     # User administration
     #-------------------------------------------------------
@@ -759,7 +739,7 @@ module Aerospike
     # before sending to server.
     def create_user(user, password, roles, options = nil)
       policy = create_policy(options, AdminPolicy, default_admin_policy)
-      hash = AdminCommand.hash_password(password)
+      hash = LoginCommand.hash_password(password)
       command = AdminCommand.new
       command.create_user(@cluster, policy, user, hash, roles)
     end
@@ -776,7 +756,7 @@ module Aerospike
       raise Aerospike::Exceptions::Aerospike.new(INVALID_USER) unless @cluster.user && @cluster.user != ""
       policy = create_policy(options, AdminPolicy, default_admin_policy)
 
-      hash = AdminCommand.hash_password(password)
+      hash = LoginCommand.hash_password(password)
       command = AdminCommand.new
 
       if user == @cluster.user
@@ -818,6 +798,50 @@ module Aerospike
       command.query_users(@cluster, policy)
     end
 
+    # Retrieve privileges for a given role.
+    def query_role(role, options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.query_role(@cluster, policy, role)
+    end
+
+    # Retrieve all roles and their privileges.
+    def query_roles(options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.query_roles(@cluster, policy)
+    end
+
+    # Create a user-defined role.
+    # Quotas require server security configuration "enable-quotas" to be set to true.
+    # Pass 0 for quota values for no limit.
+    def create_role(role_name, privileges = [], allowlist = [], read_quota = 0, write_quota = 0, options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.create_role(@cluster, policy, role_name, privileges, allowlist, read_quota, write_quota)
+    end
+
+    # Remove a user-defined role.
+    def drop_role(role_name, options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.drop_role(@cluster, policy, role_name)
+    end
+
+    # Grant privileges to a user-defined role.
+    def grant_privileges(role_name, privileges, options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.grant_privileges(@cluster, policy, role_name, privileges)
+    end
+
+    # Revoke privileges from a user-defined role.
+    def revoke_privileges(role_name, privileges, options = nil)
+      policy = create_policy(options, AdminPolicy, default_admin_policy)
+      command = AdminCommand.new
+      command.revoke_privileges(@cluster, policy, role_name, privileges)
+    end
+
     private
 
     def set_default_policies(policies)
@@ -942,7 +966,5 @@ module Aerospike
 
       threads.each(&:join)
     end
-
   end # class
-
 end # module

data/lib/aerospike/cluster/create_connection.rb

@@ -32,7 +32,7 @@ module Aerospike
           ).tap do |conn|
             if cluster.credentials_given?
               # Authenticate will raise and close connection if invalid credentials
-              Connection::Authenticate.(conn, cluster.user, cluster.password)
+              Connection::AuthenticateNew.(conn, cluster)
             end
           end
         end

data/lib/aerospike/cluster.rb

@@ -27,9 +27,12 @@ module Aerospike
     attr_reader :features, :tls_options
     attr_reader :cluster_id, :aliases
     attr_reader :cluster_name
+    attr_reader :client_policy
     attr_accessor :rack_aware, :rack_id
+    attr_accessor :session_token, :session_expiration
 
     def initialize(policy, hosts)
+      @client_policy = policy
       @cluster_seeds = hosts
       @fail_if_not_connected = policy.fail_if_not_connected
       @connection_queue_size = policy.connection_queue_size
@@ -56,7 +59,7 @@ module Aerospike
       # setup auth info for cluster
       if policy.requires_authentication
         @user = policy.user
-        @password = AdminCommand.hash_password(policy.password)
+        @password = LoginCommand.hash_password(policy.password)
       end
 
       initialize_tls_host_names(hosts) if tls_enabled?
@@ -78,6 +81,15 @@ module Aerospike
       !(@user.nil? || @user.empty?)
     end
 
+    def session_valid?
+      @session_token && @session_expiration && @session_expiration.to_i < Time.now.to_i
+    end
+
+    def reset_session_info
+      @session_token = nil
+      @session_expiration = nil
+    end
+
     def tls_enabled?
       !tls_options.nil? && tls_options[:enable] != false
     end
@@ -230,6 +242,27 @@ module Aerospike
       batch_read_node(partition, replica_policy)
     end
 
+    # Returns partitions pertaining to a node
+    def node_partitions(node, namespace)
+      res = []
+
+      partition_map = partitions
+      replica_array = partition_map[namespace]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !replica_array
+
+      node_array = (replica_array.get)[0]
+      raise Aerospike::Exceptions::InvalidNamespace("namespace not found in the partition map") if !node_array
+
+
+      pid = 0
+      for tnode in node_array.get
+        res << pid if node == tnode
+        pid+=1
+      end
+
+      res
+    end
+
     # Returns a random node on the cluster
     def random_node
       # Must copy array reference for copy on write semantics to work.
@@ -415,6 +448,7 @@ module Aerospike
         cluster_config_changed = true
       end
 
+
       cluster_config_changed
     end
 
@@ -429,7 +463,7 @@ module Aerospike
       count = -1
       done = false
 
-      # will run until the cluster is stablized
+      # will run until the cluster is stabilized
       thr = Thread.new do
         loop do
           tend
@@ -441,14 +475,17 @@ module Aerospike
           # Break if timed out
           break if done
 
-          sleep(0.001) # sleep for a milisecond
+          sleep(0.001) # sleep for a millisecond
 
           count = nodes.length
         end
       end
 
       # wait for the thread to finish or timeout
-      thr.join(@connection_timeout)
+      # This will give the client up to 10 times the timeout duration to find
+      # a host and connect successfully eventually, in case the DNS
+      # returns multiple IPs and some of them are not reachable.
+      thr.join(@connection_timeout * 10)
       done = true
       sleep(0.001)
       thr.kill if thr.alive?