pandemic 0.5.4

data/examples/client/pandemic_client.yml

@@ -0,0 +1,3 @@
+servers:
+  - localhost:4000
+  - localhost:4001

data/examples/server/pandemic_server.yml

@@ -0,0 +1,3 @@
+servers:
+  - localhost:4000
+  - localhost:4001

data/examples/server/word_count_server.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'pandemic'
+require 'json'
+
+class WordCounter < Pandemic::ServerSide::Handler
+  def partition(request, servers)
+    # select only the alive servers (non-disconnected)
+    only_alive = servers.keys.select{|k| servers[k] != :disconnected}
+    
+    mapping = {}
+    intervals = (request.body.size / only_alive.size.to_f).floor
+    
+    pos = 0
+    only_alive.size.times do |i|
+      if i == only_alive.size - 1 # last peer gets the rest
+        mapping[only_alive[i]] = request.body[pos..-1]
+      else
+        next_pos = request.body[(pos + intervals)..-1].index(/ /) + pos + intervals
+        mapping[only_alive[i]] = request.body[pos...next_pos]
+        pos = next_pos
+      end
+    end
+    mapping
+  end
+  
+  def process(text)
+    counts = Hash.new(0)
+    text.scan(/\w+/) do |word|
+      counts[word.strip.downcase] += 1
+    end
+    counts.to_json
+  end
+  
+  def reduce(request)
+    total_counts = Hash.new(0)
+    request.responses.each do |counts|
+      JSON.parse(counts).each do |word, count|
+        total_counts[word] += count
+      end
+    end
+    total_counts.to_json
+  end
+end
+
+server = epidemic!
+server.handler = WordCounter
+server.start.join

data/lib/pandemic.rb

@@ -0,0 +1,42 @@
+require 'socket'
+require 'fastthread' if RUBY_VERSION < '1.9'
+require 'thread'
+require 'monitor'
+require 'yaml'
+require 'digest/md5'
+require 'logger'
+require 'optparse'
+
+require 'pandemic/util'
+require 'pandemic/connection_pool'
+require 'pandemic/mutex_counter'
+require 'pandemic/requests_per_second'
+
+require 'pandemic/server_side/config'
+require 'pandemic/server_side/client'
+require 'pandemic/server_side/server'
+require 'pandemic/server_side/peer'
+require 'pandemic/server_side/request'
+require 'pandemic/server_side/handler'
+require 'pandemic/server_side/processor'
+
+require 'pandemic/client_side/config'
+require 'pandemic/client_side/cluster_connection'
+require 'pandemic/client_side/connection'
+require 'pandemic/client_side/connection_proxy'
+require 'pandemic/client_side/pandemize'
+
+TCP_NO_DELAY_AVAILABLE =
+    RUBY_VERSION < '1.9' ? Socket.constants.include?('TCP_NODELAY') : Socket.constants.include?(:TCP_NODELAY)
+
+MONITOR_TIMEOUT_AVAILABLE = (RUBY_VERSION < '1.9')
+def epidemic!(options = {})
+  if $pandemic_logger.nil?
+    $pandemic_logger = Logger.new(options[:log_file] || "pandemic.log")
+    $pandemic_logger.level = options[:log_level] || Logger::INFO
+    $pandemic_logger.datetime_format = "%Y-%m-%d %H:%M:%S "
+  end
+  Pandemic::ServerSide::Server.boot(options[:bind_to])
+end
+
+::Pandemize = Pandemic::ClientSide::Pandemize

data/lib/pandemic/client_side/cluster_connection.rb

@@ -0,0 +1,194 @@
+module Pandemic
+  module ClientSide
+    class ClusterConnection
+      class NotEnoughConnectionsTimeout < StandardError; end
+      class NoNodesAvailable < StandardError; end
+      class LostConnectionToNode < StandardError; end
+      class NodeTimedOut < StandardError; end
+      class RequestFailed < StandardError; end
+      
+      include Util
+      def initialize
+        Config.load
+        @connections = []
+        @available = []
+        @grouped_connections = Hash.new { |hash, key| hash[key] = [] }
+        @grouped_available = Hash.new { |hash, key| hash[key] = [] }
+        @mutex = Monitor.new
+        @connection_proxies = {}
+        @queue = @mutex.new_cond # TODO: there should be a queue for each group
+        
+        @response_timeout = Config.response_timeout
+        @response_timeout = nil if @response_timeout <= 0
+        
+        Config.servers.each_with_index do |server_addr, key|
+          @connection_proxies[key] = ConnectionProxy.new(key, self)
+          host, port = host_port(server_addr)
+          Config.min_connections_per_server.times do
+            add_connection_for_key(key)
+          end
+        end
+        
+        maintain_minimum_connections!
+      end
+      
+      
+      def [](key)
+        @connection_proxies[key % @connection_proxies.size]
+      end
+      
+      def request(body, key = nil, options = {})
+        key, options = nil, key if key.is_a?(Hash)
+        with_connection(key) do |socket|
+          begin
+            raise LostConnectionToNode if socket.nil?
+            flags = []
+            if options[:async]
+              flags << "a"
+            end
+            flags = flags.empty? ? "" : " #{flags.join("")}"
+            
+            socket.write("#{body.size}#{flags}\n#{body}")
+            socket.flush
+            
+            unless options[:async]
+              is_ready = IO.select([socket], nil, nil, @response_timeout)
+              raise NodeTimedOut if is_ready.nil?
+              response_size = socket.gets
+              if response_size && response_size.to_i >= 0
+                socket.read(response_size.to_i)
+              elsif response_size && response_size.to_i < 0
+                raise RequestFailed
+              else
+                # nil response size
+                raise LostConnectionToNode
+              end
+            end
+          rescue Errno::ECONNRESET, Errno::EPIPE
+            raise LostConnectionToNode
+          end
+        end
+      end
+      
+      def shutdown
+        @connections.each {|c| c.socket.close if c.alive? }
+        @maintain_minimum_connections_thread.kill if @maintain_minimum_connections_thread
+      end
+      
+      private
+      def with_connection(key, &block)
+        connection = nil
+        begin
+          connection = checkout_connection(key)
+          block.call(connection.socket)
+        rescue LostConnectionToNode
+          connection.died!
+          raise
+        ensure
+          checkin_connection(connection) if connection
+        end
+      end
+      
+      def checkout_connection(key)
+        connection = nil
+        select_from = key.nil? ? @available : @grouped_available[key]
+        all_connections = key.nil? ? @connections : @grouped_connections[key]
+        @mutex.synchronize do
+          loop do
+            if select_from.size > 0
+              connection = select_from.pop
+              connection.ensure_alive!
+              if !connection.alive?
+                # it's dead
+                delete_connection(connection)
+                next
+              end
+              
+              if key.nil?
+                @grouped_available[key].delete(connection)
+              else
+                @available.delete(connection)
+              end
+              break
+            elsif (connection = create_connection(key)) && connection.alive?
+              @connections << connection
+              @grouped_connections[key] << connection
+              break
+            elsif all_connections.size > 0 && @queue.wait(Config.connection_wait_timeout)
+              next
+            else
+              if all_connections.size > 0
+                raise NotEnoughConnectionsTimeout
+              else
+                raise NoNodesAvailable
+              end
+            end
+          end
+        end
+        return connection
+      end
+      
+      def checkin_connection(connection)
+        @mutex.synchronize do
+          @available.unshift(connection)
+          @grouped_available[connection.key].unshift(connection)
+          @queue.signal
+        end
+      end
+      
+      def create_connection(key)
+        if key.nil?
+          # find a key where we can add more connections
+          min, min_key = nil, nil
+          @grouped_connections.each do |key, list|
+            if min.nil? || list.size < min
+              min_key = key
+              min = list.size
+            end
+          end
+          key = min_key
+        end
+        return nil if @grouped_connections[key].size >= Config.max_connections_per_server
+        host, port = host_port(Config.servers[key])
+        Connection.new(host, port, key)
+      end
+      
+      def add_connection_for_key(key)
+        connection = create_connection(key)
+        if connection.alive?
+          @connections << connection
+          @available << connection
+          @grouped_connections[key] << connection
+          @grouped_available[key] << connection
+        end
+      end
+      
+      def delete_connection(connection)
+        @connections.delete(connection)
+        @available.delete(connection)
+        @grouped_connections[connection.key].delete(connection)
+        @grouped_available[connection.key].delete(connection)
+      end
+      
+      def maintain_minimum_connections!
+        return if @maintain_minimum_connections_thread
+        @maintain_minimum_connections_thread = Thread.new do
+          loop do
+            sleep 60 #arbitrary
+            @mutex.synchronize do
+              @grouped_connections.keys.each do |key|
+                currently_exist = @grouped_connections[key].size
+                if currently_exist < Config.min_connections_per_server
+                  (Config.min_connections_per_server - currently_exist).times do
+                    add_connection_for_key(key)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/pandemic/client_side/config.rb

@@ -0,0 +1,34 @@
+module Pandemic
+  module ClientSide
+    class Config
+      class << self
+        @@load_mutex = Mutex.new
+        attr_accessor :config_path, :loaded
+        attr_accessor :servers, :max_connections_per_server, :min_connections_per_server,
+                      :connection_wait_timeout, :response_timeout
+        def load
+          @@load_mutex.synchronize do
+            return if self.loaded
+            path = config_path
+            yaml = YAML.load_file(path)
+
+            @servers = yaml['servers'] || []
+            # this is just so if we copy/paste from server's yml to client's yml, it will still work
+            @servers = @servers.values if @servers.is_a?(Hash)
+            @servers.sort! # so it's consistent across all clients
+
+            @max_connections_per_server = (yaml['max_connections_per_server'] || 1).to_i
+            @min_connections_per_server = (yaml['min_connections_per_server'] || 1).to_i
+            @connection_wait_timeout = (yaml['connection_wait_timeout'] || 1).to_f
+            @response_timeout = (yaml['response_timeout'] || 1).to_f
+            self.loaded = true
+          end
+        end
+      
+        def config_path
+          @config_path || "pandemic_client.yml"
+        end
+      end
+    end
+  end
+end

data/lib/pandemic/client_side/connection.rb

@@ -0,0 +1,40 @@
+module Pandemic
+  module ClientSide
+    class Connection
+      attr_reader :key, :socket
+      def initialize(host, port, key)
+        @host, @port, @key = host, port, key
+        connect
+      end
+      
+      def alive?
+        @socket && !@socket.closed?
+      end
+      
+      def ensure_alive!
+        connect unless self.alive?
+      end
+      
+      def died!
+        @socket.close if self.alive?
+        @socket = nil
+      end
+
+      private
+      def connect
+        @socket = begin
+          connection = TCPSocket.new(@host, @port)
+          if connection && !connection.closed?
+            connection.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if TCP_NO_DELAY_AVAILABLE
+            connection.write("CLIENT\n")
+            connection
+          else
+            nil
+          end
+        rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/pandemic/client_side/connection_proxy.rb

@@ -0,0 +1,15 @@
+module Pandemic
+  module ClientSide
+    class ConnectionProxy
+      instance_methods.each {|m| undef_method(m) if m !~ /^__/ && m !~ /object_id/ }
+      
+      def initialize(key, cluster)
+        @key, @cluster = key, cluster
+      end
+      
+      def request(body, options = {})
+        @cluster.request(body, @key, options)
+      end      
+    end
+  end
+end

data/lib/pandemic/client_side/pandemize.rb

@@ -0,0 +1,17 @@
+module Pandemic
+  module ClientSide
+    module Pandemize
+      def self.included(klass)
+        klass.class_eval do
+          @pandemize_connection ||= Pandemic::ClientSide::ClusterConnection.new
+          def self.pandemize_connection
+            @pandemize_connection
+          end
+        end
+      end
+      def pandemic
+        self.class.pandemize_connection
+      end
+    end
+  end
+end

data/lib/pandemic/connection_pool.rb

@@ -0,0 +1,194 @@
+module Pandemic
+  class ConnectionPool
+    class TimedOutWaitingForConnectionException < StandardError; end
+    class CreateConnectionUndefinedException < StandardError; end
+    include Util
+    def initialize(options = {})
+      @connected = false
+      @mutex = Monitor.new
+      @queue = @mutex.new_cond
+      @available = []
+      @connections = []
+      @max_connections = options[:max_connections] || 10
+      @min_connections = options[:min_connections] || 1
+      @connect_at_define = options.include?(:connect_at_define) ? options[:connect_at_define] : true
+      @timeout = MONITOR_TIMEOUT_AVAILABLE ? options[:timeout] || 3 : nil
+    end
+    
+    def add_connection!
+      # bang because we're ignoring the max connections
+      @mutex.synchronize do
+        conn = create_connection
+        @available << conn if conn && !conn.closed?
+      end
+    end
+    
+    def create_connection(&block)
+      if block.nil?
+        if @create_connection
+          conn = @create_connection.call
+          if conn && !conn.closed?
+            @connections << conn
+            @connected = true 
+            conn
+          end
+        else
+          raise CreateConnectionUndefinedException.new("You must specify a block to create connections")
+        end
+      else
+        @create_connection = block
+        connect if @connect_at_define
+      end
+    end
+    
+    def destroy_connection(connection = nil, &block)
+      if block.nil?
+        if @destroy_connection
+          @destroy_connection.call(connection)
+        else
+          if connection && !connection.closed?
+            # defaul behavior is this
+            connection.close
+          end
+        end
+        @connections.delete(connection)
+        @available.delete(connection)
+        # this is within the mutex of the caller
+        @connected = false if @connections.empty?
+      else
+        @destroy_connection = block
+      end
+    end
+    
+    def status_check(connection = nil, &block)
+      if block.nil?
+        if @status_check
+          @status_check.call(connection)
+        else
+          connection && !connection.closed?
+        end
+      else
+        @status_check = block
+      end
+    end    
+    
+    def connected?
+      @connected
+    end
+    
+    def connect
+      if !connected?
+        @min_connections.times { add_connection! }
+        grim_reaper
+      end
+    end
+    
+    def available_count
+      @available.size
+    end
+    
+    def connections_count
+      @connections.size
+    end
+    
+    def disconnect
+      @mutex.synchronize do
+        return if @disconnecting
+        @disconnecting = true
+        @connected = false # we don't want anyone thinking they can use this connection
+        @grim_reaper.kill if @grim_reaper && @grim_reaper.alive?
+        
+        @available.dup.each do |conn|
+          destroy_connection(conn)
+        end
+        
+        while @connections.size > 0 && @queue.wait
+          @available.dup.each do |conn|
+            destroy_connection(conn)
+          end
+        end
+        @disconnecting = false
+      end
+    end
+    
+    def with_connection(&block)
+      connection = nil
+      begin
+        connection = checkout
+        block.call(connection)
+      ensure
+        checkin(connection) if connection
+      end
+    end
+    
+    private
+    
+    def checkout
+      connection = nil
+      @mutex.synchronize do
+        loop do
+          if @available.size > 0
+            connection = @available.pop
+            break
+          elsif @connections.size < @max_connections && (connection = create_connection)
+            break
+          elsif @queue.wait(@timeout)
+            next
+          else
+            raise TimedOutWaitingForConnectionException
+          end
+        end
+      end
+      return connection
+    end
+    
+    def checkin(connection)
+      @mutex.synchronize do
+        @available.unshift(connection)
+        @queue.signal
+      end
+    end
+    
+    def grim_reaper
+      @grim_reaper.kill if @grim_reaper && @grim_reaper.alive?
+      @grim_reaper = Thread.new do
+        usage_history = []
+        loop do
+          if connected?
+            @mutex.synchronize do
+              dead = []
+
+              @connections.each do |conn|
+                dead << conn if !status_check(conn)
+              end
+
+              dead.each { |c| destroy_connection(c) }
+              
+              # restore to minimum number of connections if it's too low
+              [@min_connections - @connections.size, 0].max.times do
+                add_connection!
+              end
+
+              usage_history.push(@available.size)
+              if usage_history.size >= 10
+                # kill the minimum number of available connections over the last 10 checks
+                # or the total connections minux the min connections, whichever is lower.
+                # this ensures that you never go below min connections
+                to_kill = [usage_history.min, @connections.size - @min_connections].min
+                [to_kill, 0].max.times do
+                  destroy_connection(@connections.last)
+                end
+                usage_history = []
+              end
+
+            end # end mutex
+            sleep 30
+          else
+            break
+          end # end if connected
+        end
+      end
+    end
+    
+  end
+end