hawatel_tlb 0.1.0

data/lib/hawatel_tlb/mode.rb

@@ -0,0 +1,5 @@
+require 'hawatel_tlb/mode/ratio'
+require 'hawatel_tlb/mode/dynamicratio'
+require 'hawatel_tlb/mode/roundrobin'
+require 'hawatel_tlb/mode/fastest'
+require 'hawatel_tlb/mode/weighted'

data/lib/hawatel_tlb/mode/dynamicratio.rb

@@ -0,0 +1,75 @@
+module HawatelTlb::Mode
+  ##
+  # = Dynamic Ratio algorithm
+  #
+  # Thease are dynamic load balancing algorithm based on dynamic ratio weights.
+  # Algorithm explanation:
+  # 1. Weight for each node is setting up by following formula:
+  #    100 - (respond_time / sum_respond_time) * 100
+  #    Weights are refreshing once per minute
+  # 2. divide the amount of traffic (requests) sent to each server by weight (configured in the Client)
+  # 3. Sort by ratio (result from 1. point) from smallest to largest
+  # 4. Get node with smallest ratio
+  # If you want to see how it works you can set client.mode.debug to 1 and run dynamicratio_spec.rb.
+  # @!attribute [rw] debug
+  #   0: enable, 1: disable
+  class DynamicRatio < Ratio
+    attr_accessor :recalc_interval
+
+    RECALC_WEIGHT_INTERVAL = 10
+
+    def initialize(group)
+      super(group)
+
+      @recalc_interval = RECALC_WEIGHT_INTERVAL
+      @dynamic_weight = 1
+      set_weights
+      thread_start
+    end
+
+    # Destroy thread
+    def destroy
+      @dynamic_weight = 0
+    end
+
+    private
+
+    def sum_respond_time
+      sum = 0
+      @group.each do |node|
+        if node.status[:state] == 'online' && node.state == 'enable'
+          sum += node.status[:respond_time]
+        end
+      end
+      sum
+    end
+
+    def set_weights
+      sum = sum_respond_time
+      @group.each do |node|
+        if node.status[:state] == 'online' && node.state == 'enable'
+          node.weight = 100 - ((node.status[:respond_time] / sum) * 100).to_i if !sum.zero?
+        end
+      end
+    end
+
+    def thread_start
+      @thr = Thread.new{
+        while(@dynamic_weight == 1)
+          sleep(RECALC_WEIGHT_INTERVAL)
+          thread_heartbeat
+          set_weights
+        end
+      }
+    rescue => e
+      puts "Exception: #{e.inspect}"
+    end
+
+    def thread_heartbeat
+      if @debug > 0
+        puts "#{Time.now} thread hearbeat #{Thread.current.object_id}"
+      end
+    end
+
+  end
+end

data/lib/hawatel_tlb/mode/fastest.rb

@@ -0,0 +1,111 @@
+module HawatelTlb::Mode
+  class Fastest
+
+    # number of elements stored in history array
+    HISTORY_SIZE = 3
+
+    def initialize(group)
+      @group   = group
+      @history = Array.new
+      @counter = 0
+    end
+
+    # Refresh group table after delete or add host
+    #
+    # @param group [Array<Hash>]
+    def refresh(group)
+      @group = group
+    end
+
+    # Calculate base on fastest algorithm
+    # Algorithm based on history statistics about respond time and 'online' states (flapping detection)
+    #
+    # @return [Hash] hostname/ip address and port number
+    def node
+      # push nodes statistics to history array
+      if @counter < HISTORY_SIZE
+        @history[@counter] = @group.dup
+        @counter += 1
+      else
+        @counter = 0
+        @history[@counter] = @group.dup
+      end
+
+      current_online = Array.new
+      @group.each do |node|
+        current_online.push(node.id) if node.state == 'enable' && node.status[:state] == 'online'
+      end
+
+      # there is no any available node
+      return false if current_online.empty?
+
+      # there is only one available node
+      return find_node(current_online[0]) if current_online.size == 1
+
+      # there are more that one online nodes
+      nodes_sorted_stats = sort_by_state(average_respond_time(current_online))
+
+      # choose only top nodes with equal online state
+      top_nodes_by_state = Array.new
+      top_value = 0
+      nodes_sorted_stats.each do |node|
+        top_value = node[:online_count] if top_value == 0
+        if node[:online_count] == top_value
+          top_nodes_by_state.push(node)
+        else
+          break
+        end
+      end
+
+      # there is only one node with highest online count
+      return find_node(top_nodes_by_state[0][:id]) if top_nodes_by_state.size == 1
+
+      # there are more with top
+      top_nodes_by_respond = sort_by_respond(top_nodes_by_state)
+      find_node(top_nodes_by_respond[0][:id])
+    end
+
+    private
+    # sort decedent nodes by online counter
+    def sort_by_state(nodes)
+      sorted_nodes = Array.new
+      nodes.each_with_index do |node, index|
+        next if node.nil?
+        node[:id] = index
+        sorted_nodes.push(node)
+      end
+      sorted_nodes.sort_by { |node| node[:online_count]}.reverse!
+    end
+
+    # sort by average respond time
+    def sort_by_respond(nodes)
+      nodes.sort_by { |node| node[:avg_respond_time]}
+    end
+
+    # return node hostname and port based on node id
+    def find_node(node_id)
+      node_param = @group.select {|node| node[:id] == node_id}
+      {:host => node_param[0].host, :port => node_param[0].port}
+    end
+
+    # calculate average respond time time for online nodes
+    def average_respond_time(current_online)
+      stats = Array.new
+      @history.each do |round|
+        round.each do |node|
+          if node.status[:state] == 'online' && current_online.include?(node.id)
+            stats[node.id] = Hash.new if !stats[node.id].is_a?(Hash)
+            !stats[node.id][:online_count] ? stats[node.id][:online_count] = 1 : stats[node.id][:online_count] += 1
+            !stats[node.id][:sum_respond_time] ?
+                stats[node.id][:sum_respond_time] = node.status[:respond_time] :
+                stats[node.id][:sum_respond_time] += node.status[:respond_time]
+            !stats[node.id][:avg_respond_time] ?
+                stats[node.id][:avg_respond_time] = node.status[:respond_time] :
+                stats[node.id][:avg_respond_time] = stats[node.id][:sum_respond_time] / stats[node.id][:online_count]
+          end
+        end
+      end
+      return stats
+    end
+  end
+end

data/lib/hawatel_tlb/mode/ratio.rb

@@ -0,0 +1,101 @@
+module HawatelTlb::Mode
+  ##
+  # = Ratio algorithm
+  #
+  # Thease are static load balancing algorithm based on ratio weights.
+  # Algorithm explanation:
+  # 1. divide the amount of traffic (requests) sent to each server by weight (configured in the Client)
+  # 2. Sort by ratio (result from 1. point) from smallest to largest
+  # 3. Get node with smallest ratio
+  # If you want to see how it works you can set client.mode.debug to 1 and run ratio_spec.rb.
+  # @!attribute [rw] debug
+  class Ratio
+    attr_accessor :debug
+
+    def initialize(group)
+      @traffic = 0
+      @debug = 0
+
+      group.each do |node|
+        node.ratio = Hash.new
+        node.ratio[:traffic] = 0
+        node.ratio[:value] = 0
+
+        node.weight = 1 if node.weight.to_i < 1
+      end
+
+      @group = group
+    end
+
+    # Refresh group table after delete or add host
+    #
+    # @param group [Array<Hash>]
+    def refresh(group)
+      @group = group
+    end
+
+    # Description
+    # @param name [Type] description
+    # @option name [Type] :opt description
+    # @example
+    #   mode = Ratio.new(nodes)
+    #   p mode.node
+    # @return [Hash] :host and :port
+    def node
+      node = get_right_node
+      return {:host => node.host, :port => node.port} if node
+      false
+    end
+
+    private
+
+    def get_right_node
+      nodes = sort_nodes_by_ratio_asc
+      node = get_first_online_node(nodes)
+      debug_log(nodes)
+
+      if node
+        set_ratio(node)
+        return node
+      else
+        false
+      end
+    end
+
+    def get_first_online_node(nodes)
+      nodes.each do |node|
+        return node if node.status[:state] == 'online' && node.state == 'enable'
+      end
+      false
+    end
+
+    def sort_nodes_by_ratio_asc
+      @group.sort_by {|node| node.ratio[:value]}
+    end
+
+    def set_ratio(node)
+      @traffic += 1
+      node.ratio[:traffic] += 1
+      node.ratio[:value] = calc_ratio(node.ratio[:traffic], node.weight)
+    end
+
+    def calc_ratio(traffic, weight)
+      if weight.zero?
+        0
+      else
+        traffic.to_f / weight.to_f
+      end
+    end
+
+    def debug_log(nodes)
+      if @debug > 0
+        puts ">> request: #{@traffic} | selected #{nodes[0].host}"
+        nodes.each do |node|
+          puts "\t" "#{node.host} - ratio: #{node.ratio}, weight: #{node.weight}\n"
+        end
+        puts "------------------------------------------------------------"
+      end
+    end
+
+  end
+end

data/lib/hawatel_tlb/mode/roundrobin.rb

@@ -0,0 +1,50 @@
+module HawatelTlb
+  module Mode
+
+    ##
+    # = Overview
+    #
+    # Details
+    #
+    # @!attribute [rw] name
+    #   @return [Type] description
+    class RoundRobin
+
+      def initialize(group)
+        @group = group
+        @round = Array.new
+      end
+
+      # Refresh group table after delete or add host
+      #
+      # @param group [Array<Hash>]
+      def refresh(group)
+        @group = group
+      end
+
+      # Return ip address based on Round Robin algorithm
+      #
+      # @return [Hash] hostname/ip address and port number
+      def node
+        counter    = 0
+        first_item = ''
+        @group.each do |node|
+          if !node.status.empty?
+            if node.status[:state] == 'online' && node.state == 'enable'
+              first_item = {:host => node.host, :port => node.port} if counter == 0
+              if !@round.include?(node.id)
+                @round.push(node.id)
+                return {:host => node.host, :port => node.port}
+              end
+              counter += 1
+            end
+          end
+        end
+        @round = Array.new
+        return first_item if !first_item.empty?
+        false
+      end
+
+    end
+  end
+end

data/lib/hawatel_tlb/mode/weighted.rb

@@ -0,0 +1,102 @@
+module HawatelTlb::Mode
+  class Weighted
+
+    # number of elements stored in history array
+    HISTORY_SIZE = 3
+
+    def initialize(group)
+      @group   = group
+      @history = Array.new
+      @counter = 0
+    end
+
+    # Refresh group table after delete or add host
+    #
+    # @param group [Array<Hash>]
+    def refresh(group)
+      @group = group
+    end
+
+    #
+    # @return [Hash] hostname/ip address and port number
+    def node
+
+      # push nodes statistics to history array
+      if @counter < HISTORY_SIZE
+        @history[@counter] = @group.dup
+        @counter += 1
+      else
+        @counter = 0
+        @history[@counter] = @group.dup
+      end
+
+      # build array with only
+      current_online = Array.new
+      @group.each do |node|
+        current_online.push(node.id) if node.state == 'enable' && node.status[:state] == 'online'
+      end
+
+      # there is no any available node
+      return false if current_online.empty?
+
+      # there is only one available node
+      return find_node(current_online[0]) if current_online.size == 1
+
+      # there is more that one nodes - choose the most reliable node
+      nodes_reliability = Array.new
+      @history.each do |round|
+        round.each do |node|
+          if node.state == 'enable' && node.status[:state] == 'online'
+            nodes_reliability[node.id] =  Hash.new if nodes_reliability[node.id].nil?
+            nodes_reliability[node.id][:online_count] = 0 if nodes_reliability[node.id][:online_count].nil?
+            nodes_reliability[node.id][:online_count] += 1
+          end
+        end
+      end
+
+      # choose only top nodes with equal online state
+      top_nodes_by_state = Array.new
+      top_value = 0
+      sort_by_state(nodes_reliability).each do |node|
+        top_value = node[:online_count] if top_value == 0
+        if node[:online_count] == top_value
+          node_param = @group.select {|item| item[:id] == node[:hostid]}
+          top_nodes_by_state << node_param
+        else
+          break
+        end
+      end
+
+      # there is only one node with highest online count
+      return {:host => top_nodes_by_state[0][:host], port => top_nodes_by_state[0][:port]} if top_nodes_by_state.size == 1
+
+      # find node with highest weight
+      nodes = sort_by_weight(top_nodes_by_state)
+      return {:host => nodes[0][0].host, :port => nodes[0][0].port}
+    end
+
+    private
+    # return node hostname and port based on node id
+    def find_node(node_id)
+      node_param = @group.select {|node| node[:id] == node_id}
+      {:host => node_param[0].host, :port => node_param[0].port}
+    end
+
+    # sort nodes by online counter
+    def sort_by_state(nodes)
+      sorted_nodes = Array.new
+      nodes.each_with_index do |node, index|
+        next if node.nil?
+        node[:hostid] = index
+        sorted_nodes.push(node)
+      end
+      sorted_nodes.sort_by { |node| node[:online_count]}.reverse!
+    end
+
+    # sort by average weight
+    def sort_by_weight(nodes)
+      nodes.sort_by { |node| node[0].weight }.reverse!
+    end
+
+  end
+end