aerospike 0.1.0

data/lib/aerospike/cluster/connection.rb

@@ -0,0 +1,113 @@
+# 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.
+
+require 'socket'
+
+module Aerospike
+
+  private
+
+  class Connection
+
+    def initialize(host, port, timeout = 30)
+
+      connect(host, port, timeout).tap do |socket|
+        @socket = socket
+        @timeout = timeout
+      end
+
+      self
+    end
+
+    def connect(host, port, timeout)
+      socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      sockaddr = Socket.sockaddr_in(port, host)
+      begin
+        socket.connect_nonblock(sockaddr)
+      rescue Errno::EINPROGRESS
+        # Block until the socket is ready, then try again
+        IO.select([socket], [socket], [socket], timeout.to_f)
+        @sockaddr = sockaddr
+        return socket
+      end
+    end
+
+    def write(buffer, length)
+      total = 0
+      while total < length
+        begin
+          written = @socket.write_nonblock(buffer.read(total, length - total))
+          total += written
+        rescue IO::WaitWriteable, Errno::EAGAIN
+          IO.select(nil, [@socket])
+          retry
+        rescue => e
+          Aerospike::Exceptions::Connection.new("#{e}")
+        end
+      end
+    end
+
+    def read(buffer, length)
+      total = 0
+      while total < length
+        begin
+          bytes = @socket.recv_nonblock(length - total)
+          buffer.write_binary(bytes, total) if bytes.bytesize > 0
+          total += bytes.bytesize
+        rescue IO::WaitReadable,  Errno::EAGAIN
+          IO.select([@socket], nil)
+          retry
+        rescue => e
+          Aerospike::Exceptions::Connection.new("#{e}")
+        end
+      end
+    end
+
+    def connected?
+      @socket != nil
+    end
+
+    def valid?
+      @socket != nil
+    end
+
+    def close
+      @socket.close if @socket
+      @socket = nil
+    end
+
+    def timeout=(timeout)
+      if timeout > 0 && timeout != @timeout
+        @timeout = timeout
+        # if IO.select([@socket], [@socket], [@socket], timeout.to_f)
+        if IO.select(nil, nil, nil, timeout.to_f)
+          begin
+            # Verify there is now a good connection
+            @socket.connect_nonblock(@sockaddr)
+          rescue Errno::EISCONN
+            # operation successful
+          rescue => e
+            # An unexpected exception was raised - the connection is no good.
+            close
+            raise Aerospike::Exceptions::Connection.new("#{e}")
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/aerospike/cluster/node.rb

@@ -0,0 +1,248 @@
+# 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.
+
+require 'atomic'
+
+module Aerospike
+
+  private
+
+  class Node
+
+    attr_reader :reference_count, :responded, :name
+
+    PARTITIONS = 4096
+    FULL_HEALTH = 100
+
+    # Initialize server node with connection parameters.
+    def initialize(cluster, nv)
+      @cluster = cluster
+      @name = nv.name
+      @aliases = Atomic.new(nv.aliases)
+      @host = nv.host
+      @use_new_info = Atomic.new(nv.use_new_info)
+
+      # Assign host to first IP alias because the server identifies nodes
+      # by IP address (not hostname).
+      @host =                nv.aliases[0]
+      @health =              Atomic.new(FULL_HEALTH)
+      @partition_generation = Atomic.new(-1)
+      @reference_count =      Atomic.new(0)
+      @responded =           Atomic.new(false)
+      @active =              Atomic.new(true)
+
+      @connections =         Pool.new(@cluster.connection_queue_size)
+      @connections.create_block = Proc.new do
+        while conn = Connection.new(@host.name, @host.port, @cluster.connection_timeout)
+          break if conn.connected?
+        end
+        conn
+      end
+
+      @connections.cleanup_block = Proc.new { |conn| conn.close }
+    end
+
+    # Request current status from server node, and update node with the result
+    def refresh
+      friends = []
+      conn = get_connection(1)
+
+      begin
+        info_map = Info.request(conn, "node", "partition-generation", "services")
+      rescue => e
+        conn.close
+        decrease_health
+
+        raise e
+      end
+
+      verify_node_name(info_map)
+      restore_health
+
+      @responded.update{|v| true}
+
+      friends = add_friends(info_map)
+      update_partitions(conn, info_map)
+      put_connection(conn)
+      friends
+    end
+
+    # Get a connection to the node. If no cached connection is not available,
+    # a new connection will be created
+    def get_connection(timeout)
+      while true
+        conn = @connections.poll
+        if conn.connected?
+          conn.timeout = timeout.to_f
+          return conn
+        end
+      end
+    end
+
+    # Put back a connection to the cache. If cache is full, the connection will be
+    # closed and discarded
+    def put_connection(conn)
+      conn.close if !@active.value
+      @connections.offer(conn)
+    end
+
+    # Mark the node as healthy
+    def restore_health
+      # There can be cases where health is full, but active is false.
+      # Once a node has been marked inactive, it stays inactive.
+      @health.value = FULL_HEALTH
+    end
+
+    # Decrease node Health as a result of bad connection or communication
+    def decrease_health
+      @health.update {|v| v -= 1 }
+    end
+
+    # Check if the node is unhealthy
+    def unhealthy?
+      @health.value <= 0
+    end
+
+    # Retrieves host for the node
+    def get_host
+      @host
+    end
+
+    # Checks if the node is active
+    def active?
+      @active.value
+    end
+
+    # Returns node name
+    def get_name
+      @name
+    end
+
+    # Returns node aliases
+    def get_aliases
+      @aliases.value
+    end
+
+    # Adds an alias for the node
+    def add_alias(alias_to_add)
+      # Aliases are only referenced in the cluster tend threads,
+      # so synchronization is not necessary.
+      aliases = get_aliases
+      aliases ||= []
+
+      aliases << alias_to_add
+      set_aliases(aliases)
+    end
+
+    # Marks node as inactice and closes all cached connections
+    def close
+      @active.value = false
+      close_connections
+    end
+
+    # Implements stringer interface
+    def to_s
+      "#{@name}:#{@host}"
+    end
+
+    def ==(other)
+      other && other.is_a?(Node) && (@name == other.name)
+    end
+    alias eql? ==
+
+    def use_new_info?
+      @use_new_info.value
+    end
+
+    def hash
+      @name.hash
+    end
+
+    private
+
+    def close_connections
+      # drain connections and close all of them
+      # non-blocking, does not call create_block when passed false
+      while conn = @connections.poll(false)
+        conn.close
+      end
+    end
+
+
+    # Sets node aliases
+    def set_aliases(aliases)
+      @aliases.value = aliases
+    end
+
+    def verify_node_name(info_map)
+      info_name = info_map['node']
+
+      if !info_name
+        decrease_health
+        raise Aerospike::Exceptions.Aerospike.new("Node name is empty")
+      end
+
+      if !(@name == info_name)
+        # Set node to inactive immediately.
+        @active.update{|v| false}
+        raise Aerospike::Exceptions.Aerospike.new("Node name has changed. Old=#{@name} New= #{info_name}")
+      end
+    end
+
+    def add_friends(info_map)
+      friend_string = info_map['services']
+      friends = []
+
+      return [] if friend_string.to_s.empty?
+
+      friend_names = friend_string.split(';')
+
+      friend_names.each do |friend|
+        friend_info = friend.split(':')
+        host = friend_info[0]
+        port = friend_info[1].to_i
+        aliass = Host.new(host, port)
+        node = @cluster.find_alias(aliass)
+
+        if node
+          node.reference_count.update{|v| v + 1}
+        else
+          unless friends.any? {|host| host == aliass}
+            friends << aliass
+          end
+        end
+      end
+
+      friends
+    end
+
+    def update_partitions(conn, info_map)
+      gen_string = info_map['partition-generation']
+
+      raise Aerospike::Exceptions::Parse.new("partition-generation is empty") if gen_string.to_s.empty?
+
+      generation = gen_string.to_i
+
+      if @partition_generation.value != generation
+        Aerospike.logger.info("Node #{get_name} partition generation #{generation} changed")
+        @cluster.update_partitions(conn, self)
+        @partition_generation.value = generation
+      end
+    end
+
+  end # class Node
+
+end # module

data/lib/aerospike/cluster/node_validator.rb

@@ -0,0 +1,85 @@
+# 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
+
+  class NodeValidator
+
+    attr_reader :host, :aliases, :name, :use_new_info
+
+    def initialize(host, timeout)
+      @use_new_info = true
+      @host = host
+
+      set_aliases(host)
+      set_address(timeout)
+
+      self
+    end
+
+    def set_aliases(host)
+      addresses = Resolv.getaddresses(host.name)
+      aliases = []
+      addresses.each do |addr|
+        aliases << Host.new(addr, host.port)
+      end
+
+      @aliases = aliases
+
+      Aerospike.logger.debug("Node Validator has #{aliases.length} nodes.")
+    end
+
+    def set_address(timeout)
+      @aliases.each do |aliass|
+        begin
+          conn = Connection.new(aliass.name, aliass.port, 1)
+          conn.timeout = timeout
+
+          info_map= Info.request(conn, 'node', 'build')
+          if node_name = info_map['node']
+            @name = node_name
+
+            # Check new info protocol support for >= 2.6.6 build
+            if build_version = info_map['build']
+              v1, v2, v3 = parse_version_string(build_version)
+              @use_new_info = v1.to_i > 2 || (v1.to_i == 2 && (v2.to_i > 6 || (v2.to_i == 6 && v3.to_i >= 6)))
+            end
+          end
+        ensure
+          conn.close if conn
+        end
+
+      end
+    end
+
+    protected
+
+    # parses a version string
+    @@version_regexp = /(?<v1>\d+)\.(?<v2>\d+)\.(?<v3>\d+).*/
+
+    def parse_version_string(version)
+      if v = @@version_regexp.match(version)
+        return v['v1'], v['v2'], v['v3']
+      end
+
+      raise Aerospike::Exceptions::Parse.new("Invalid build version string in Info: #{version}")
+    end
+
+  end # class
+
+end #module

data/lib/aerospike/cluster/partition.rb

@@ -0,0 +1,54 @@
+# 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
+
+  class Partition
+    attr_reader :namespace, :partition_id
+
+    def initialize(namespace, partition_id)
+      @namespace = namespace
+      @partition_id = partition_id
+
+      self
+    end
+
+    def self.new_by_key(key)
+      Partition.new(
+        key.namespace,
+        (key.digest[0..3].unpack('l<')[0] & 0xFFFF) % Node::PARTITIONS
+      )
+    end
+
+    def to_s
+      "#{@namespace}:#{partition_id}"
+    end
+
+    def ==(other)
+      other && other.is_a?(Partition) && @partition_id == other.partition_id &&
+        @namespace == other.namespace
+    end
+    alias eql? ==
+
+    def hash
+      to_s.hash
+    end
+
+  end # class
+
+end # module