arya-pandemic 0.2

data/README.markdown

@@ -0,0 +1,99 @@
+# Pandemic
+Pandemic is a map-reduce framework. You give it the map, process, and reduce methods and it handles the rest. It works both in Ruby 1.8 and Ruby 1.9, and performs better on 1.9.
+
+## Usage
+### Server
+    
+    require 'rubygems'
+    require 'pandemic'
+
+    class Handler < Pandemic::ServerSide::Handler
+      def process(body)
+        body.reverse
+      end
+    end
+
+    pandemic_server = epidemic!
+    pandemic_server.handler = Handler.new
+    pandemic_server.start.join
+
+In this example, the handler doesn't define the map or reduce methods, and the defaults are used. The default for each is as follows:
+
+  * map: Send the full request body to every connected node
+  * process: Return the body (do nothing)
+  * reduce: Concatenate all the responses
+
+### Client
+
+    require 'rubygems'
+    require 'pandemic'
+
+    class TextFlipper
+      include Pandemize
+      def flip(str)
+        pandemic.request(str)
+      end
+    end
+
+
+### Config
+Both the server and client have config files:
+
+    # pandemic_server.yml
+    servers:
+      - host1:4000
+      - host2:4000
+    response_timeout: 0.5
+
+Each value for the server list is the _host:port_ that a node can bind to. The servers value can be a hash or an array of hashes, but I'll get to that later. The response timeout is how long to wait for responses from nodes before returning to the client.
+
+    # pandemic_client.yml
+    servers:
+      - host1:4000
+      - host2:4000
+    max_connections_per_server: 10
+    min_connections_per_server: 1
+The min/max connections refers to how many connections to each node. If you're using Rails, then just use 1 for both min/max since it's single threaded.
+
+### More Config
+There are three ways to start a server:
+
+  * ruby server.rb -i 0
+  * ruby server.rb -i machine1hostname
+  * ruby server.rb -a localhost:4000
+  
+The first refers to the index in the servers array:
+
+    servers:
+      - host1:4000 # started with ruby server.rb -i 0
+      - host2:4000 # started with ruby server.rb -i 0
+      
+The second refers to the index in the servers _hash_. This can be particularly useful if you use the hostname as the key.
+
+    servers:
+      machine1: host1:4000 # started with ruby server.rb -i machine1
+      machine2: host2:4000 # started with ruby server.rb -i machine2
+      
+The third is to specify the host and port explicitly. Ensure that the host and port you specify is actually in the config otherwise the other nodes won't be able to communicate with it.
+
+You can also set node-specific configuration options.
+
+    servers:
+      - host1:4000:
+          database: pandemic_node_1
+          host: localhost
+          username: foobar
+          password: f00bar
+      - host2:4000:
+          database: pandemic_node_2
+          host: localhost
+          username: fizzbuzz
+          password: f1zzbuzz
+            
+And you can access these additional options using _config.get(keys)_ in your handler:
+
+    class Handler < Pandemic::ServerSide::Handler
+      def initialize
+        @dbh = Mysql.real_connect(*config.get('host', 'username', 'password', 'database')) 
+      end
+    end

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('pandemic', '0.2') do |p|
+  p.description    = "Distribute MapReduce to any of the workers and it will spread, like a pandemic."
+  p.url            = ""
+  p.author         = "Arya Asemanfar"
+  p.email          = "aryaasemanfar@gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*", 'config.yml']
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/lib/pandemic.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'socket'
+require 'fastthread' if RUBY_VERSION < '1.9'
+require 'thread'
+require 'monitor'
+require 'yaml'
+require 'digest/md5'
+require 'logger'
+
+require 'pandemic/util'
+require 'pandemic/connection_pool'
+require 'pandemic/mutex_counter'
+
+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/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'
+
+# TODO:
+# - IO timeouts/robustness
+# - documentation
+# - PING/PONG?
+
+$logger = Logger.new(STDOUT)
+$logger.level = Logger::DEBUG
+$logger.datetime_format = "%Y-%m-%d %H:%M:%S "
+
+def epidemic!
+  Pandemic::ServerSide::Server.boot
+end
+
+::Pandemize = Pandemic::ClientSide::Pandemize

data/lib/pandemic/client_side/cluster_connection.rb

@@ -0,0 +1,129 @@
+module Pandemic
+  module ClientSide
+    class ClusterConnection
+      class NotEnoughConnectionsTimeout < Exception; end
+      class NoNodesAvailable < Exception; end
+      class LostConnectionToNode < Exception; 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
+        
+        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
+            connection = create_connection(key)
+            if connection.alive?
+              @connections << connection
+              @available << connection
+              @grouped_connections[key] << connection
+              @grouped_available[key] << connection
+            end
+          end
+        end
+      end
+      
+      
+      def [](key)
+        @connection_proxies[key]
+      end
+      
+      def request(body, key = nil)
+        with_connection(key) do |socket|
+          begin
+            socket.write("#{body.size}\n#{body}")
+            socket.flush
+            # IO.select([socket])
+            response_size = socket.gets
+            if response_size
+              socket.read(response_size.strip.to_i)
+            else
+              # nil response size
+              raise LostConnectionToNode
+            end
+          rescue Errno::ECONNRESET
+            raise LostConnectionToNode
+          end
+        end
+      end
+      
+      private
+      def with_connection(key, &block)
+        connection = nil
+        begin
+          connection = checkout_connection(key)
+          block.call(connection.socket)
+        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
+              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
+      
+      #TODO: a thread to manage killing and reviving connections
+    end
+  end
+end

data/lib/pandemic/client_side/config.rb

@@ -0,0 +1,33 @@
+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
+        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
+            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,31 @@
+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
+
+      private
+      def connect
+        @socket = begin
+          connection = TCPSocket.new(@host, @port)
+          if connection && !connection.closed?
+            connection.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if Socket.constants.include?('TCP_NODELAY')
+            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)
+        @cluster.request(body, @key)
+      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,117 @@
+module Pandemic
+  class ConnectionPool
+    class TimedOutWaitingForConnectionException < Exception; end
+    class CreateConnectionUndefinedException < Exception; end
+    include Util
+    def initialize(options = {})
+      @mutex = Monitor.new
+      @queue = @mutex.new_cond
+      @available = []
+      @connections = []
+      @max_connections = options[:max_connections] || 10
+      @timeout = options[:timeout] || 3
+    end
+    
+    def add_connection!
+      # bang because we're ignorings the max connections
+      conn = create_connection
+      if conn
+        @mutex.synchronize do
+          @connections << conn
+          @available << conn
+        end
+      end
+    end
+    
+    def create_connection(&block)
+      if block.nil?
+        if @create_connection
+          @create_connection.call
+        else
+          raise CreateConnectionUndefinedException.new("You must specify a block to create connections")
+        end
+      else
+        @create_connection = block
+      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
+      else
+        @destroy_connection = block
+      end
+    end
+    
+    def connected?
+      @mutex.synchronize { @connections.size > 0 }
+    end
+    
+    def disconnect
+      @mutex.synchronize do
+        return if @disconnecting
+        @disconnecting = true
+        @available.each do |conn|
+          destroy_connection(conn)
+          @connections.delete(conn)
+        end
+        @available = []
+        while @connections.size > 0 && @queue.wait
+          @available.each do |conn|
+            destroy_connection(conn)
+            @connections.delete(conn)
+          end
+          @available = []
+        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)
+            @connections << 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
+    
+  end
+end