aerospike 2.19.0 → 2.26.0

data/lib/aerospike/node_validator.rb

@@ -40,6 +40,7 @@ module Aerospike
 
     def get_hosts(address)
       aliases = [get_alias(address, host.port)]
+      res = []
 
       begin
         conn = Cluster::CreateConnection.(@cluster, Host.new(address, host.port, host.tls_name))
@@ -61,11 +62,15 @@ module Aerospike
         unless is_loopback?(address)
           aliases = info_map[address_command].split(',').map { |addr| get_alias(*addr.split(':')) }
         end
+
+        res = aliases.map { |al| Host.new(al[:address], al[:port], host.tls_name) }
+      rescue
+        # we don't care about the actual connection error; Just need to continue
       ensure
         conn.close if conn
       end
 
-      aliases.map { |al| Host.new(al[:address], al[:port], host.tls_name) }
+      res
     end
 
     def get_alias(address, port)

data/lib/aerospike/operation.rb

@@ -14,30 +14,30 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'aerospike/value/value'
+require "aerospike/value/value"
 
 module Aerospike
-
   class Operation
-
     attr_reader :op_type, :bin_name, :bin_value, :ctx
 
-    READ        = 1
+    READ = 1
     READ_HEADER = 1
-    WRITE       = 2
-    CDT_READ    = 3
-    CDT_MODIFY  = 4
-    ADD         = 5
-    APPEND      = 9
-    PREPEND     = 10
-    TOUCH       = 11
-    BIT_READ    = 12
-    BIT_MODIFY  = 13
-    DELETE      = 14
-    HLL_READ    = 15
-    HLL_MODIFY  = 16
-
-    def initialize(op_type, bin_name=nil, bin_value=NullValue.new, ctx = nil)
+    WRITE = 2
+    CDT_READ = 3
+    CDT_MODIFY = 4
+    ADD = 5
+    EXP_READ = 7
+    EXP_MODIFY = 8
+    APPEND = 9
+    PREPEND = 10
+    TOUCH = 11
+    BIT_READ = 12
+    BIT_MODIFY = 13
+    DELETE = 14
+    HLL_READ = 15
+    HLL_MODIFY = 16
+
+    def initialize(op_type, bin_name = nil, bin_value = NullValue.new, ctx = nil)
       @op_type = op_type
       @bin_name = bin_name
       @bin_value = Value.of(bin_value)
@@ -49,11 +49,11 @@ module Aerospike
       Aerospike::Bin.new(bin_name, bin_value) if bin_name && bin_value
     end
 
-    def self.get(bin_name=nil)
+    def self.get(bin_name = nil)
       Operation.new(READ, bin_name)
     end
 
-    def self.get_header(bin_name=nil)
+    def self.get_header(bin_name = nil)
       Operation.new(READ_HEADER, bin_name)
     end
 
@@ -80,7 +80,5 @@ module Aerospike
     def self.delete
       Operation.new(DELETE)
     end
-
   end
-
 end # module

data/lib/aerospike/policy/auth_mode.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# Copyright 2014-2020 Aerospike, Inc.
+#
+# 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
+
+  module AuthMode
+
+    # INTERNAL uses internal authentication only when user/password defined. Hashed password is stored
+    # on the server. Do not send clear password. This is the default.
+    INTERNAL = 0
+
+    # EXTERNAL uses external authentication (like LDAP) when user/password defined. Specific external authentication is
+    # configured on server. If TLS is defined, sends clear password on node login via TLS.
+    # Will raise exception if TLS is not defined.
+    EXTERNAL = 1
+
+    # PKI allows authentication and authorization based on a certificate. No user name or
+    # password needs to be configured. Requires TLS and a client certificate.
+    # Requires server version 5.7.0+
+    PKI = 2
+
+  end # module
+
+end # module

data/lib/aerospike/policy/client_policy.rb

@@ -22,7 +22,7 @@ module Aerospike
   # Container object for client policy command.
   class ClientPolicy
 
-    attr_accessor :user, :password
+    attr_accessor :user, :password, :auth_mode
     attr_accessor :timeout, :connection_queue_size, :fail_if_not_connected, :tend_interval
     attr_accessor :cluster_name
     attr_accessor :tls
@@ -44,6 +44,9 @@ module Aerospike
       # which the client checks for cluster state changes. Minimum interval is 10ms.
       self.tend_interval = opt[:tend_interval] || 1000 # 1 second
 
+      # Authentication mode
+      @auth_mode = opt[:auth_mode] || AuthMode::INTERNAL
+
       # user name
       @user = opt[:user]
 

data/lib/aerospike/policy/policy.rb

@@ -13,23 +13,44 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'aerospike/policy/priority'
-require 'aerospike/policy/consistency_level'
-require 'aerospike/policy/replica'
-
+require "aerospike/policy/priority"
+require "aerospike/policy/consistency_level"
+require "aerospike/policy/replica"
 
 module Aerospike
 
   # Container object for client policy command.
   class Policy
-
-    attr_accessor :priority, :timeout, :max_retries, :sleep_between_retries, :consistency_level,
+    attr_accessor :filter_exp, :priority, :timeout, :max_retries, :sleep_between_retries, :consistency_level,
                   :predexp, :fail_on_filtered_out, :replica, :use_compression
 
-    def initialize(opt={})
+    alias total_timeout timeout
+    alias total_timeout= timeout=
+
+    def initialize(opt = {})
       # Container object for transaction policy attributes used in all database
       # operation calls.
 
+      # Optional expression filter. If filterExp exists and evaluates to false, the
+      # transaction is ignored.
+      #
+      # Default: nil
+      #
+      # ==== Examples:
+      #
+      # p = Policy.new
+      # p.filter_exp = Exp.build(Exp.eq(Exp.int_bin("a"), Exp.int_val(11)));
+      @filter_exp = opt[:filter_exp]
+
+      #  Throw exception if {#filter_exp} is defined and that filter evaluates
+      #  to false (transaction ignored).  The {AerospikeException}
+      #  will contain result code {ResultCode::FILTERED_OUT}.
+      #
+      #  This field is not applicable to batch, scan or query commands.
+      #
+      #  Default: false
+      @fail_on_filtered_out = opt[:fail_on_filtered_out] || false
+
       # Priority of request relative to other transactions.
       # Currently, only used for scans.
       @priority = opt[:priority] || Priority::DEFAULT
@@ -71,7 +92,6 @@ module Aerospike
       # ]
       @predexp = opt[:predexp] || nil
 
-
       # Throw exception if @predexp is defined and that filter evaluates
       # to false (transaction ignored). The Aerospike::Exceptions::Aerospike
       # will contain result code Aerospike::ResultCode::FILTERED_OUT.
@@ -83,9 +103,8 @@ module Aerospike
       # read operation.
       @consistency_level = opt[:consistency_level] || Aerospike::ConsistencyLevel::CONSISTENCY_ONE
 
-
       # Send read commands to the node containing the key's partition replica type.
-      # Write commands are not affected by this setting, because all writes are directed 
+      # Write commands are not affected by this setting, because all writes are directed
       # to the node containing the key's master partition.
       #
       # Default to sending read commands to the node containing the key's master partition.
@@ -115,8 +134,5 @@ module Aerospike
       # timeout was not exceeded. Enter zero to skip sleep.
       @sleep_between_retries = opt[:sleep_between_retries] || 0.5
     end
-
-
   end # class
-
 end # module

data/lib/aerospike/policy/query_policy.rb

@@ -22,20 +22,45 @@ module Aerospike
   # Container object for query policy command.
   class QueryPolicy < Policy
 
+    attr_accessor :concurrent_nodes
+    attr_accessor :max_records
     attr_accessor :include_bin_data
     attr_accessor :record_queue_size
     attr_accessor :records_per_second
+    attr_accessor :socket_timeout
+    attr_accessor :short_query
 
     def initialize(opt={})
       super(opt)
 
-      @max_retries = 0
-
       # Indicates if bin data is retrieved. If false, only record digests (and
       # user keys if stored on the server) are retrieved.
       # Default is true.
       @include_bin_data = opt.fetch(:include_bin_data, true)
 
+      # Approximates the number of records to return to the client. This number is divided by the
+      # number of nodes involved in the query. The actual number of records returned
+      # may be less than MaxRecords if node record counts are small and unbalanced across
+      # nodes.
+      #
+      # This field is supported on server versions >= 4.9.
+      #
+      # Default: 0 (do not limit record count)
+      @max_records = opt.fetch(:max_records) { 0 }
+
+      # Issue scan requests in parallel or serially.
+      @concurrent_nodes = opt.fetch(:concurrent_nodes) { true }
+
+      # Determines network timeout for each attempt.
+      #
+      # If socket_timeout is not zero and socket_timeout is reached before an attempt completes,
+      # the Timeout above is checked. If Timeout is not exceeded, the transaction
+      # is retried. If both socket_timeout and Timeout are non-zero, socket_timeout must be less
+      # than or equal to Timeout, otherwise Timeout will also be used for socket_timeout.
+      #
+      # Default: 30s
+      @socket_timeout = opt[:socket_timeout] || 30000
+
       # Number of records to place in queue before blocking. Records received
       # from multiple server nodes will be placed in a queue. A separate thread
       # consumes these records in parallel. If the queue is full, the producer
@@ -49,6 +74,14 @@ module Aerospike
       # Default is 0
       @records_per_second = opt[:records_per_second] || 0
 
+      # Detemine wether query expected to return less than 100 records.
+      # If true, the server will optimize the query for a small record set.
+      # This field is ignored for aggregation queries, background queries
+      # and server versions 6.0+.
+      #
+      # Default: false
+      @short_query = opt[:short_query] ||false
+
       self
     end
 

data/lib/aerospike/policy/scan_policy.rb

@@ -22,6 +22,7 @@ module Aerospike
   # Container object for scan policy command.
   class ScanPolicy < Policy
 
+    attr_accessor :max_records
     attr_accessor :scan_percent
     attr_accessor :concurrent_nodes
     attr_accessor :include_bin_data
@@ -33,7 +34,15 @@ module Aerospike
     def initialize(opt={})
       super(opt)
 
-      @max_retries = 0
+      # Approximates the number of records to return to the client. This number is divided by the
+      # number of nodes involved in the query. The actual number of records returned
+      # may be less than MaxRecords if node record counts are small and unbalanced across
+      # nodes.
+      #
+      # This field is supported on server versions >= 4.9.
+      #
+      # Default: 0 (do not limit record count)
+      @max_records = opt.fetch(:max_records) { 0 }
 
       # Percent of data to scan. Valid integer range is 1 to 100.
       # Default is 100.
@@ -51,7 +60,15 @@ module Aerospike
       # Default is true.
       @fail_on_cluster_change = opt.fetch(:fail_on_cluster_change) { true }
 
-      @socket_timeout = opt[:socket_timeout] || 10000
+      # Determines network timeout for each attempt.
+      #
+      # If socket_timeout is not zero and socket_timeout is reached before an attempt completes,
+      # the Timeout above is checked. If Timeout is not exceeded, the transaction
+      # is retried. If both socket_timeout and Timeout are non-zero, socket_timeout must be less
+      # than or equal to Timeout, otherwise Timeout will also be used for socket_timeout.
+      #
+      # Default: 30s
+      @socket_timeout = opt[:socket_timeout] || 30000
 
       # Number of records to place in queue before blocking. Records received
       # from multiple server nodes will be placed in a queue. A separate thread

data/lib/aerospike/privilege.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+# Copyright 2014-2022 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
+
+	# Determines user access granularity.
+	class Privilege
+
+		# Role
+		attr_accessor :code
+
+		# Namespace determines namespace scope. Apply permission to this namespace only.
+		# If namespace is zero value, the privilege applies to all namespaces.
+		attr_accessor :namespace
+
+		# Set name scope. Apply permission to this set within namespace only.
+		# If set is zero value, the privilege applies to all sets within namespace.
+		attr_accessor :set_name
+
+	    # Manage users and their roles.
+	    USER_ADMIN = 'user-admin'
+
+	    # Manage indicies, user-defined functions and server configuration.
+	    SYS_ADMIN = 'sys-admin'
+
+	    # Manage indicies and user defined functions.
+	    DATA_ADMIN = 'data-admin'
+
+	    # Manage user defined functions.
+	    UDF_ADMIN = 'udf-admin'
+
+	    # Manage indicies.
+	    SINDEX_ADMIN = 'sindex-admin'
+
+	    # Allow read, write and UDF transactions with the database.
+	    READ_WRITE_UDF = "read-write-udf"
+
+	    # Allow read and write transactions with the database.
+	    READ_WRITE = 'read-write'
+
+	    # Allow read transactions with the database.
+	    READ = 'read'
+
+	    # Write allows write transactions with the database.
+	    WRITE = 'write'
+
+	    # Truncate allow issuing truncate commands.
+	    TRUNCATE = 'truncate'
+
+	    def initialize(opt={})
+	      @code = opt[:code]
+	      @namespace = opt[:namespace]
+	      @set_name = opt[:set_name]
+	    end
+
+		def to_s
+			"code: #{@code}, namespace: #{@namespace}, set_name: #{@set_name}"
+		end
+
+		def to_code
+			case @code
+			when USER_ADMIN
+				0
+			when SYS_ADMIN
+				1
+			when DATA_ADMIN
+				2
+			when UDF_ADMIN
+				3
+			when SINDEX_ADMIN
+				4
+			when READ
+				10
+			when READ_WRITE
+				11
+			when READ_WRITE_UDF
+				12
+			when WRITE
+				13
+			when TRUNCATE
+				14
+			else
+				raise Exceptions::Aerospike.new(Aerospike::ResultCode::INVALID_PRIVILEGE, "Invalid role #{@code}")
+			end # case
+		end # def
+
+		def self.from(code)
+			case code
+			when 0
+				USER_ADMIN
+			when 1
+				SYS_ADMIN
+			when 2
+				DATA_ADMIN
+			when 3
+				UDF_ADMIN
+			when 4
+				SINDEX_ADMIN
+			when 10
+				READ
+			when 11
+				READ_WRITE
+			when 12
+				READ_WRITE_UDF
+			when 13
+				WRITE
+			when 14
+				TRUNCATE
+			else
+				raise Exceptions::Aerospike.new(Aerospike::ResultCode::INVALID_PRIVILEGE, "Invalid code #{code}")
+			end # case
+		end # def
+
+		def can_scope?
+			to_code >= 10
+		end
+
+	end # class
+
+end

data/lib/aerospike/query/filter.rb

@@ -15,39 +15,51 @@
 # the License.
 
 module Aerospike
-
   class Filter
+    attr_reader :packed_ctx
 
-    def self.Equal(bin_name, value)
-      Filter.new(bin_name, value, value)
-    end
+    # open up the class to alias the class methods for naming consistency
+    class << self
+      def equal(bin_name, value, ctx: nil)
+        Filter.new(bin_name, value, value, nil, nil, ctx)
+      end
 
-    def self.Contains(bin_name, value, col_type)
-      Filter.new(bin_name, value, value, nil, col_type)
-    end
+      def contains(bin_name, value, col_type, ctx: nil)
+        Filter.new(bin_name, value, value, nil, col_type, ctx)
+      end
 
-    def self.Range(bin_name, from, to, col_type = nil)
-      Filter.new(bin_name, from, to, nil, col_type)
-    end
+      def range(bin_name, from, to, col_type = nil, ctx: nil)
+        Filter.new(bin_name, from, to, nil, col_type, ctx)
+      end
 
-    def self.geoWithinGeoJSONRegion(bin_name, region, col_type = nil)
-      region = region.to_json
-      Filter.new(bin_name, region, region, ParticleType::GEOJSON, col_type)
-    end
+      def geo_within_geo_region(bin_name, region, col_type = nil, ctx: nil)
+        region = region.to_json
+        Filter.new(bin_name, region, region, ParticleType::GEOJSON, col_type, ctx)
+      end
 
-    def self.geoWithinRadius(bin_name, lon, lat, radius_meter, col_type = nil)
-      region = GeoJSON.new({type: "AeroCircle", coordinates: [[lon, lat], radius_meter]})
-      geoWithinGeoJSONRegion(bin_name, region, col_type)
-    end
+      def geo_within_radius(bin_name, lon, lat, radius_meter, col_type = nil, ctx: nil)
+        region = GeoJSON.new({ type: "AeroCircle", coordinates: [[lon, lat], radius_meter] })
+        geo_within_geo_region(bin_name, region, col_type, ctx: ctx)
+      end
 
-    def self.geoContainsGeoJSONPoint(bin_name, point, col_type = nil)
-      point = point.to_json
-      Filter.new(bin_name, point, point, ParticleType::GEOJSON, col_type)
-    end
+      def geo_contains_geo_point(bin_name, point, col_type = nil, ctx: nil)
+        point = point.to_json
+        Filter.new(bin_name, point, point, ParticleType::GEOJSON, col_type, ctx)
+      end
 
-    def self.geoContainsPoint(bin_name, lon, lat, col_type = nil)
-      point = GeoJSON.new({type: "Point", coordinates: [lon, lat]})
-      geoContainsGeoJSONPoint(bin_name, point, col_type)
+      def geo_contains_point(bin_name, lon, lat, col_type = nil, ctx: nil)
+        point = GeoJSON.new({ type: "Point", coordinates: [lon, lat] })
+        geo_contains_geo_point(bin_name, point, col_type, ctx: ctx)
+      end
+
+      # alias the old names for compatibility
+      alias :Equal :equal
+      alias :Contains :contains
+      alias :Range :range
+      alias :geoWithinGeoJSONRegion :geo_within_geo_region
+      alias :geoWithinRadius :geo_within_radius
+      alias :geoContainsGeoJSONPoint :geo_contains_geo_point
+      alias :geoContainsPoint :geo_contains_point
     end
 
     def estimate_size
@@ -56,21 +68,21 @@ module Aerospike
 
     def write(buf, offset)
       # Write name.
-      len = buf.write_binary(@name, offset+1)
+      len = buf.write_binary(@name, offset + 1)
       buf.write_byte(len, offset)
       offset += len + 1
 
       # Write particle type.
       buf.write_byte(@val_type, offset)
-      offset+=1
+      offset += 1
 
       # Write filter begin.
-      len = @begin.write(buf, offset+4)
+      len = @begin.write(buf, offset + 4)
       buf.write_int32(len, offset)
       offset += len + 4
 
       # Write filter end.
-      len = @end.write(buf, offset+4)
+      len = @end.write(buf, offset + 4)
       buf.write_int32(len, offset)
       offset += len + 4
 
@@ -98,7 +110,7 @@ module Aerospike
 
     private
 
-    def initialize(bin_name, begin_value, end_value, val_type = nil, col_type = nil)
+    def initialize(bin_name, begin_value, end_value, val_type = nil, col_type = nil, ctx = nil)
       @name = bin_name
       @begin = Aerospike::Value.of(begin_value)
       @end = Aerospike::Value.of(end_value)
@@ -107,8 +119,8 @@ module Aerospike
       # but in certain cases caller can override the type.
       @val_type = val_type || @begin.type
       @col_type = col_type
-    end
 
+      @packed_ctx = CDT::Context.bytes(ctx)
+    end
   end # class
-
 end

data/lib/aerospike/query/node_partitions.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# 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.
+
+module Aerospike
+  class NodePartitions
+    attr_accessor :node, :parts_full, :parts_partial, :record_count, :record_max, :parts_unavailable
+
+    def initialize(node)
+        @node= node
+        @parts_full=    []
+        @parts_partial= []
+        @record_count= 0
+        @parts_unavailable= 0
+        @record_max= 0
+    end
+
+    def to_s
+      "Node #{@node.inspect}: full: #{@parts_full.length}, partial: #{@parts_partial.length}"
+    end
+
+    def add_partition(partition_status)
+      partition_status.digest.nil? ? @parts_full << partition_status : @parts_partial << partition_status
+    end
+  end
+end