aerospike 0.1.6 → 1.0.0

data/lib/aerospike/cluster/node_validator.rb

@@ -18,11 +18,12 @@ module Aerospike
 
   private
 
-  class NodeValidator
+  class NodeValidator # :nodoc:
 
     attr_reader :host, :aliases, :name, :use_new_info
 
-    def initialize(host, timeout)
+    def initialize(cluster, host, timeout)
+      @cluster = cluster
       @use_new_info = true
       @host = host
 
@@ -47,8 +48,19 @@ module Aerospike
     def set_address(timeout)
       @aliases.each do |aliass|
         begin
-          conn = Connection.new(aliass.name, aliass.port, 1)
-          conn.timeout = timeout
+          conn = Connection.new(aliass.name, aliass.port, timeout)
+
+          # need to authenticate
+          if @cluster.user && @cluster.user != ''
+            begin
+              command = AdminCommand.new
+              command.authenticate(conn, @cluster.user, @cluster.password)
+            rescue => e
+              # Socket not authenticated. Do not put back into pool.
+              conn.close if conn
+              raise e
+            end
+          end
 
           info_map= Info.request(conn, 'node', 'build')
           if node_name = info_map['node']

data/lib/aerospike/cluster/partition.rb

@@ -18,7 +18,7 @@ module Aerospike
 
   private
 
-  class Partition
+  class Partition # :nodoc:
     attr_reader :namespace, :partition_id
 
     def initialize(namespace, partition_id)

data/lib/aerospike/cluster/partition_tokenizer_new.rb

@@ -22,7 +22,7 @@ module Aerospike
 
   REPLICAS_NAME = 'replicas-master'
 
-  class PartitionTokenizerNew
+  class PartitionTokenizerNew #:nodoc:
 
     def initialize(conn)
       # Use low-level info methods and parse byte array directly for maximum performance.
@@ -97,11 +97,13 @@ module Aerospike
 
           bit_map_length = @offset - beginning
           restore_buffer = Base64.strict_decode64(@buffer[beginning, bit_map_length])
-          for i in 0...Aerospike::Node::PARTITIONS
+          i = 0
+          while i < Aerospike::Node::PARTITIONS
             if (restore_buffer[i>>3].ord & (0x80 >> (i & 7))) != 0
               # Logger.Info("Map: `" + namespace + "`," + strconv.Itoa(i) + "," + node.String)
               node_array.update{|v| v[i] = node; v}
             end
+            i = i.succ
           end
 
           @offset+=1

data/lib/aerospike/cluster/partition_tokenizer_old.rb

@@ -20,7 +20,7 @@ module Aerospike
 
   private
 
-  class PartitionTokenizerOld
+  class PartitionTokenizerOld #:nodoc:
 
     def initialize(conn)
       # Use low-level info methods and parse byte array directly for maximum performance.

data/lib/aerospike/command/admin_command.rb

@@ -0,0 +1,353 @@
+# encoding: utf-8
+# Copyright 2014 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
+
+  private
+	# Commands
+	AUTHENTICATE    = 0
+	CREATE_USER     = 1
+	DROP_USER       = 2
+	SET_PASSWORD    = 3
+	CHANGE_PASSWORD = 4
+	GRANT_ROLES     = 5
+	REVOKE_ROLES    = 6
+	REPLACE_ROLES   = 7
+	#CREATE_ROLE = 8
+	QUERY_USERS = 9
+	#QUERY_ROLES =  10
+
+	# Field IDs
+	USER         = 0
+	PASSWORD     = 1
+	OLD_PASSWORD = 2
+	CREDENTIAL   = 3
+	ROLES        = 10
+	#PRIVILEGES =  11
+
+	# Misc
+	MSG_VERSION  = 0
+	MSG_TYPE     = 2
+
+	HEADER_SIZE       = 24
+	HEADER_REMAINING  = 16
+	RESULT_CODE       = 9
+	QUERY_END         = 50
+
+	class AdminCommand #:nodoc:
+
+		def initialize
+			@data_buffer = Buffer.get
+			@data_offset =  8
+		end
+
+		def authenticate(conn, user, password)
+			begin
+				set_authenticate(user, password)
+				conn.write(@data_buffer, @data_offset)
+				conn.read(@data_buffer, HEADER_SIZE)
+
+				result = @data_buffer.read(RESULT_CODE)
+				raise Exceptions::Aerospike.new(result, "Authentication failed") if result != 0
+			ensure
+				Buffer.put(@data_buffer)
+			end
+		end
+
+		def set_authenticate(user, password)
+			write_header(AUTHENTICATE, 2)
+			write_field_str(USER, user)
+			write_field_bytes(CREDENTIAL, password)
+			write_size
+
+			return @data_offset
+		end
+
+		def create_user(cluster, policy, user, password, roles)
+			write_header(CREATE_USER, 3)
+			write_field_str(USER, user)
+			write_field_bytes(PASSWORD, password)
+			write_roles(roles)
+			execute_command(cluster, policy)
+		end
+
+		def drop_user(cluster, policy, user)
+			write_header(DROP_USER, 1)
+			write_field_str(USER, user)
+			execute_command(cluster, policy)
+		end
+
+		def set_password(cluster, policy, user, password)
+			write_header(SET_PASSWORD, 2)
+			write_field_str(USER, user)
+			write_field_bytes(PASSWORD, password)
+			execute_command(cluster, policy)
+		end
+
+		def change_password(cluster, policy, user, password)
+			write_header(CHANGE_PASSWORD, 3)
+			write_field_str(USER, user)
+			write_field_bytes(OLD_PASSWORD, cluster.password)
+			write_field_bytes(PASSWORD, password)
+			execute_command(cluster, policy)
+		end
+
+		def grant_roles(cluster, policy, user, roles)
+			write_header(GRANT_ROLES, 2)
+			write_field_str(USER, user)
+			write_roles(roles)
+			execute_command(cluster, policy)
+		end
+
+		def revoke_roles(cluster, policy, user, roles)
+			write_header(REVOKE_ROLES, 2)
+			write_field_str(USER, user)
+			write_roles(roles)
+			execute_command(cluster, policy)
+		end
+
+		def replace_roles(cluster, policy, user, roles)
+			write_header(REPLACE_ROLES, 2)
+			write_field_str(USER, user)
+			write_roles(roles)
+			execute_command(cluster, policy)
+		end
+
+		def query_user(cluster, policy, user)
+			# TODO: Remove the workaround in the future
+			sleep(0.010)
+
+			list = []
+			begin
+				write_header(QUERY_USERS, 1)
+				write_field_str(USER, user)
+				list = read_users(cluster, policy)
+				return (list.is_a?(Array) && list.length > 0 ? list.first : nil)
+			ensure
+				Buffer.put(@data_buffer)
+			end
+		end
+
+		def query_users(cluster, policy)
+			# TODO: Remove the workaround in the future
+			sleep(0.010)
+			begin
+				write_header(QUERY_USERS, 0)
+				return read_users(cluster, policy)
+			ensure
+				Buffer.put(@data_buffer)
+			end
+		end
+
+		def write_roles(roles)
+			offset = @data_offset + FIELD_HEADER_SIZE
+			@data_buffer.write_byte(roles.length.ord, offset)
+			offset += 1
+
+			roles.each do |role|
+				len = @data_buffer.write_binary(role, offset+1)
+				@data_buffer.write_byte(len, offset)
+				offset += len + 1
+			end
+
+			size = offset - @data_offset - FIELD_HEADER_SIZE
+			write_field_header(ROLES, size)
+			@data_offset = offset
+		end
+
+		def write_size
+			# Write total size of message which is the current offset.
+			size = Integer(@data_offset-8) | Integer(MSG_VERSION << 56) | Integer(MSG_TYPE << 48)
+			@data_buffer.write_int64(size, 0)
+		end
+
+		def write_header(command, field_count)
+			# Authenticate header is almost all zeros
+			i = @data_offset
+			while i < @data_offset+16
+				@data_buffer.write_byte(0, i)
+				i = i.succ
+			end
+			@data_buffer.write_byte(command, @data_offset+2)
+			@data_buffer.write_byte(field_count, @data_offset+3)
+			@data_offset += 16
+		end
+
+		def write_field_str(id, str)
+			len = @data_buffer.write_binary(str, @data_offset+FIELD_HEADER_SIZE)
+			write_field_header(id, len)
+			@data_offset += len
+		end
+
+		def write_field_bytes(id, bytes)
+			@data_buffer.write_binary(bytes, @data_offset+FIELD_HEADER_SIZE)
+			write_field_header(id, bytes.bytesize)
+			@data_offset += bytes.bytesize
+		end
+
+		def write_field_header(id, size)
+			@data_buffer.write_int32(size+1, @data_offset)
+			@data_offset += 4
+			@data_buffer.write_byte(id, @data_offset)
+			@data_offset += 1
+		end
+
+		def execute_command(cluster, policy)
+			# TODO: Remove the workaround in the future
+			sleep(0.010)
+
+			write_size
+			node = cluster.random_node
+
+			timeout = 1
+			timeout = policy.timeout if policy && policy.timeout > 0
+
+			conn = node.get_connection(timeout)
+
+			begin
+				conn.write(@data_buffer, @data_offset)
+				conn.read(@data_buffer, HEADER_SIZE)
+				node.put_connection(conn)
+			rescue => e
+				conn.close if conn
+				raise e
+			end
+
+			result = @data_buffer.read(RESULT_CODE)
+			raise Exceptions::Aerospike.new(result) if result != 0
+				
+			Buffer.put(@data_buffer)
+		end
+
+		def read_users(cluster, policy)
+			write_size
+			node = cluster.random_node
+			
+			timeout = 1
+			timeout = policy.timeout if policy != nil && policy.timeout > 0
+
+			status = -1
+			list = []
+			begin							
+				conn = node.get_connection(timeout)
+				conn.write(@data_buffer, @data_offset)
+				status, list = read_user_blocks(conn)
+				node.put_connection(conn)
+			rescue => e
+				conn.close if conn
+				raise e
+			end
+
+			raise Exceptions::Aerospike.new(result) if status > 0
+
+			return list
+		end
+
+		def read_user_blocks(conn)
+			rlist = []
+			status = 0
+			begin
+				while status == 0
+						conn.read(@data_buffer, 8)
+						size = @data_buffer.read_int64(0)
+						receive_size = (size & 0xFFFFFFFFFFFF)
+
+						if receive_size > 0
+							@data_buffer.resize(receive_size) if receive_size > @data_buffer.size
+							
+							conn.read(@data_buffer, receive_size)
+							status, list = parse_users(receive_size)
+							rlist.concat(list.to_a)
+						else
+							break
+						end
+				end
+				return status, rlist
+			rescue => e
+				return -1, []
+			end
+		end
+
+		def parse_users(receive_size)
+			@data_offset = 0
+			list = []
+
+			while @data_offset < receive_size
+				result_code = @data_buffer.read(@data_offset+1)
+
+				if result_code != 0
+					return (result_code == QUERY_END ? -1 : result_code)
+				end
+
+				userRoles = UserRoles.new
+				field_count = @data_buffer.read(@data_offset+3)
+				@data_offset += HEADER_REMAINING
+
+				i = 0
+				while i  < field_count
+					len = @data_buffer.read_int32(@data_offset)
+					@data_offset += 4
+					id = @data_buffer.read(@data_offset)
+					@data_offset += 1
+					len -= 1
+
+					case id
+						when USER
+							userRoles.user = @data_buffer.read(@data_offset, len)
+							@data_offset += len
+						when ROLES
+							parse_roles(userRoles)
+						else
+							@data_offset += len
+					end
+
+					i = i.succ
+				end
+
+				next if userRoles.user == "" && userRoles.roles == nil
+
+				userRoles.roles = [] if userRoles.roles == nil
+				list << userRoles
+			end
+
+			return 0, list
+		end
+
+		def parse_roles(userRoles)
+			size = @data_buffer.read(@data_offset)
+			@data_offset += 1
+			userRoles.roles = []
+
+			i = 0
+			while i < size
+				len = @data_buffer.read(@data_offset)
+				@data_offset += 1
+				role = @data_buffer.read(@data_offset, len)
+				@data_offset += len
+				userRoles.roles << role
+
+				i = i.succ
+			end
+		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/batch_command.rb

@@ -24,7 +24,7 @@ module Aerospike
 
   private
 
-  class BatchCommand < Command
+  class BatchCommand < Command #:nodoc:
 
     def initialize(node)
       super(node)
@@ -61,7 +61,8 @@ module Aerospike
       set_name = nil
       user_key = nil
 
-      for i in 0...field_count
+      i = 0
+      while i < field_count
         read_bytes(4)
 
         fieldlen = @data_buffer.read_int32(0)
@@ -80,6 +81,8 @@ module Aerospike
         when Aerospike::FieldType::KEY
           user_key = Aerospike::bytes_to_key_value(@data_buffer.read(1).ord, @data_buffer, 2, size-1)
         end
+
+        i = i.succ
       end
 
       Aerospike::Key.new(namespace, set_name, user_key, digest)
@@ -88,17 +91,15 @@ module Aerospike
     # Parses the given byte buffer and populate the result object.
     # Returns the number of bytes that were parsed from the given buffer.
     def parse_record(key, op_count, generation, expiration)
-      bins = nil
-      duplicates = nil
-
-      for i in 0...op_count
+      bins = op_count > 0 ? {} : nil
+      i = 0
+      while i < op_count
         raise Aerospike::Exceptions::QueryTerminated.new unless valid?
 
         read_bytes(8)
 
         op_size = @data_buffer.read_int32(0).ord
         particle_type = @data_buffer.read(5).ord
-        version = @data_buffer.read(6).ord
         name_size = @data_buffer.read(7).ord
 
         read_bytes(name_size)
@@ -114,44 +115,13 @@ module Aerospike
         # if !@bin_names || @bin_names.any?{|bn| bn == name}
         # if !@bin_names || (@bin_names == []) || @bin_names.any?{|bn| bn == name}
         if !@bin_names || (@bin_names.empty?) || @bin_names.any?{|bn| bn == name}
-
-          vmap = nil
-
-          if version > 0 || duplicates
-            unless duplicates
-              duplicates = []
-              duplicates << bins
-              bins = nil
-
-              for j in 0...version
-                duplicates << nil
-              end
-            else
-              for j in duplicates.length..version
-                duplicates << nil
-              end
-            end
-
-            vmap = duplicates[version]
-            unless vmap
-              vmap = {}
-              duplicates[version] = vmap
-            end
-          else
-            unless bins
-              bins = {}
-            end
-            vmap = bins
-          end
-          vmap[name] = value
+          bins[name] = value
         end
-      end
 
-      # Remove nil duplicates just in case there were holes in the version number space.
-      # TODO: this seems to be a bad idea; O(n) algorithm after another O(n) algorithm
-      duplicates.compact! if duplicates
+        i = i.succ
+      end
 
-      Record.new(@node, key, bins, duplicates, generation, expiration)
+      Record.new(@node, key, bins, generation, expiration)
     end
 
     def read_bytes(length)