arya-pandemic 0.2

data/lib/pandemic/mutex_counter.rb

@@ -0,0 +1,24 @@
+module Pandemic
+  class MutexCounter
+    MAX = (2 ** 30) - 1
+    def initialize
+      @mutex = Mutex.new
+      @counter = 0
+      @resets = 0
+    end
+
+    def real_total
+      @mutex.synchronize { (@resets * MAX) + @counter }
+    end
+
+    def inc
+      @mutex.synchronize do
+        if @counter >= MAX
+          @counter = 0  # to avoid Bignum, it's about 4x slower
+          @resets += 1
+        end
+        @counter += 1
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/client.rb

@@ -0,0 +1,86 @@
+module Pandemic
+  module ServerSide
+    class Client
+      class DisconnectClient < Exception; end
+      include Util
+      
+      attr_accessor :received_requests, :responded_requests
+      
+      def initialize(connection, server)
+        @connection = connection
+        @server = server
+        @received_requests = 0
+        @responded_requests = 0
+      end
+    
+      def listen
+        unless @connection.nil?
+          @listener_thread.kill if @listener_thread
+          @listener_thread = Thread.new do
+            begin
+              while @server.running
+                debug("Waiting for incoming request")
+                request = @connection.gets
+                info("Received incoming request")
+                @received_requests += 1
+                
+                if request.nil?
+                  debug("Incoming request is nil")
+                  @connection.close
+                  @connection = nil
+                  break
+                elsif request.strip! =~ /^([0-9]+)$/ # currently only asking for request size
+                  size = $1.to_i
+                  debug("Reading request body (size #{size})")
+                  body = @connection.read(size)
+                  debug("Finished reading request body")
+                  
+                  response = handle_request(body)
+                  
+                  debug("Writing response to client")
+                  @connection.write("#{response.size}\n#{response}")
+                  @connection.flush
+                  @responded_requests += 1
+                  debug("Finished writing response to client")
+                end
+              end
+            rescue DisconnectClient
+              info("Closing client connection")
+              @connection.close unless @connection.nil? || @connection.closed?
+            rescue Exception => e
+              warn("Unhandled exception in client listen thread: #{e.inspect}")
+            ensure
+              @server.client_closed(self)
+            end
+          end
+        end
+        return self
+      end
+    
+      def close
+        @listener_thread.raise(DisconnectClient)
+      end
+    
+      def handle_request(request)
+        @server.handle_client_request(Request.new(request))
+      end
+      
+      private
+      def signature
+        @signature ||= @connection.peeraddr.values_at(3,1).join(":")
+      end
+      
+      def debug(msg)
+        logger.debug("Client #{signature}") {msg}
+      end
+      
+      def info(msg)
+        logger.info("Client #{signature}") {msg}
+      end
+      
+      def warn(msg)
+        logger.warn("Client #{signature}") {msg}
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/config.rb

@@ -0,0 +1,55 @@
+module Pandemic
+  module ServerSide
+    class Config
+      class << self
+        attr_accessor :bind_to, :servers, :response_timeout
+        def load
+          path = extract_config_path
+          yaml = YAML.load_file(path)
+        
+          @server_map = yaml['servers'] || []
+          @servers = @server_map.is_a?(Hash) ? @server_map.values : @server_map 
+          @servers = @servers.collect { |s| s.is_a?(Hash) ? s.keys.first : s }
+        
+          @response_timeout = (yaml['response_timeout'] || 1).to_f
+          @bind_to = extract_bind_to
+          raise "Interface to bind to is nil." unless @bind_to
+        end
+        
+        def get(*args)
+          args.size == 1 ?  @options[args.first] : @options.values_at(*args) if @options
+        end
+        
+        private
+        def extract_bind_to
+          index = ARGV.index('-i')
+          index2 = ARGV.index('-a')
+
+          if index && (key = ARGV[index + 1])
+            key = key.to_i if @server_map.is_a?(Array)
+            server = @server_map[key]
+            if server.is_a?(Hash)
+              @options = server.values.first # there should only be one
+              @server_map[key].keys.first
+            else
+              server
+            end
+          elsif index2 && (host = ARGV[index2 + 1])
+            host
+          else
+            raise "You must specify which interface to bind to."
+          end
+        end
+      
+        def extract_config_path
+          index = ARGV.index('-c')
+          if index && (path = ARGV[index + 1])
+            path
+          else
+            "pandemic_server.yml"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/handler.rb

@@ -0,0 +1,27 @@
+module Pandemic
+  module ServerSide
+    class Handler
+      def config
+        Config
+      end
+        
+      def map(request, servers)
+        map = {}
+        servers.each do |server, status|
+          if status != :disconnected
+            map[server] = request.body
+          end
+        end
+        map
+      end
+
+      def reduce(request)
+        request.responses.join("")
+      end
+
+      def process(body)
+        body
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/peer.rb

@@ -0,0 +1,203 @@
+module Pandemic
+  module ServerSide
+    class Peer
+      class PeerUnavailableException < Exception; end
+      include Util
+      attr_reader :host, :port
+      
+      def initialize(addr, server)
+        @host, @port = host_port(addr)
+        @server = server
+        @pending_requests = with_mutex({})
+        @incoming_connection_listeners = []
+        @inc_threads_mutex = Mutex.new
+        initialize_connection_pool
+      end
+      
+      def connect
+        return if connected?
+        debug("Forced connection to peer")
+        1.times { @connection_pool.add_connection! }
+      end
+      
+      def disconnect
+        debug("Disconnecting from peer")
+        @connection_pool.disconnect
+      end
+      
+      def connected?
+        @connection_pool.connected?
+      end
+    
+      def client_request(request, body)
+        debug("Sending client's request to peer")
+        # TODO: Consider adding back threads here if it will be faster that way in Ruby 1.9
+        @connection_pool.with_connection do |connection|
+          if connection && !connection.closed?
+            @pending_requests.synchronize do
+              @pending_requests[request.hash] = request
+            end
+            debug("Writing client's request")
+            connection.write("PROCESS #{request.hash} #{body.size}\n#{body}")
+            connection.flush
+            debug("Finished writing client's request")
+          end # TODO: else? fail silently? reconnect?
+        end
+      end
+    
+      def add_incoming_connection(conn)
+        debug("Adding incoming connection")
+
+        connect # if we're not connected, we should be
+        
+        thread = Thread.new(conn) do |connection|
+          begin
+            debug("Incoming connection thread started")
+            while @server.running
+              debug("Listening for incoming requests")
+              request = connection.gets
+              debug("Read incoming request from peer")
+              
+              if request.nil?
+                debug("Incoming connection request is nil")
+                break
+              else
+                debug("Received incoming (#{request.strip})")
+                handle_incoming_request(request, connection) if request =~ /^PROCESS/
+                handle_incoming_response(request, connection) if request =~ /^RESPONSE/
+              end
+            end
+          rescue Exception => e
+            warn("Unhandled exception in peer listener thread: #{e.inspect}")
+          ensure
+            debug("Incoming connection closing")
+            conn.close if conn && !conn.closed?
+            @inc_threads_mutex.synchronize { @incoming_connection_listeners.delete(Thread.current)}
+            if @incoming_connection_listeners.empty?
+              disconnect
+            end
+          end
+        end
+        
+        @inc_threads_mutex.synchronize {@incoming_connection_listeners.push(thread) if thread.alive? }
+      end
+    
+      private
+      def initialize_connection_pool
+        return if @connection_pool
+        @connection_pool = ConnectionPool.new
+        
+        @connection_pool.create_connection do
+          connection = nil
+          begin
+            connection = TCPSocket.new(@host, @port)
+          rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED
+            connection = nil
+          rescue Exception => e
+            warn("Unhandled exception in create connection block: #{e.inspect}")
+          end
+          if connection
+            connection.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if Socket.constants.include?('TCP_NODELAY')
+            connection.write("SERVER #{@server.signature}\n")
+          end
+          connection
+        end
+        
+      end
+    
+      def handle_incoming_request(request, connection)
+        debug("Identified as request")
+        if request.strip =~ /^PROCESS ([A-Za-z0-9]+) ([0-9]+)$/
+          hash = $1
+          size = $2.to_i
+          debug("Incoming request: #{hash} #{size}")
+          begin
+            debug("Reading request body")
+            request_body = connection.read(size)
+            debug("Finished reading request body")
+          rescue EOFError, TruncatedDataError
+            debug("Failed to read request body")
+            # TODO: what to do here?
+            return false
+          rescue Exception => e
+            warn("Unhandled exception in incoming request read: #{e.inspect}")
+          end
+          debug("Processing body")
+          process_request(hash, request_body)
+        else
+          warn("Malformed incoming request: #{request.strip}")
+          # when the incoming request was malformed
+          # TODO: what to do here? 
+        end
+      end
+    
+      def handle_incoming_response(response, connection)
+        if response.strip =~ /^RESPONSE ([A-Za-z0-9]+) ([0-9]+)$/
+          hash = $1
+          size = $2.to_i
+          debug("Incoming response: #{hash} #{size}")
+          begin
+            debug("Reading response body")
+            response_body = connection.read(size)
+            debug("Finished reading response body")
+          rescue EOFError, TruncatedDataError
+            debug("Failed to read response body")
+            # TODO: what to do here?
+            return false
+          rescue Exception => e
+            warn("Unhandled exception in incoming response read: #{e.inspect}")
+          end
+          process_response(hash, response_body)
+        else
+          warn("Malformed incoming response: #{response.strip}")
+          # when the incoming response was malformed
+          # TODO: what to do here? 
+        end
+      end
+    
+    
+      def process_request(hash, body)
+        Thread.new do
+          begin
+            debug("Starting processing thread (#{hash})")
+            response = @server.process(body)
+            debug("Processing finished (#{hash})")
+            @connection_pool.with_connection do |connection|
+              debug( "Sending response (#{hash})")
+              connection.write("RESPONSE #{hash} #{response.size}\n#{response}")
+              connection.flush
+              debug( "Finished sending response (#{hash})")
+            end
+          rescue Exception => e
+            warn("Unhandled exception in process request thread: #{e.inspect}")
+          end
+        end
+      end
+    
+      def process_response(hash, body)
+        Thread.new do
+          begin
+            debug("Finding original request (#{hash})")
+            original_request = @pending_requests.synchronize { @pending_requests.delete(hash) }
+            if original_request
+              debug("Found original request, adding response")
+              original_request.add_response(body) 
+            else
+              warn("Original response not found (#{hash})")
+            end
+          rescue Exception => e
+            warn("Unhandled exception in process response thread: #{e.inspect}")
+          end
+        end
+      end
+      
+      def debug(msg)
+        logger.debug("Peer #{@host}:#{@port}")  { msg }
+      end
+      
+      def warn(msg)
+        logger.warn("Peer #{@host}:#{@port}")  { msg }
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/request.rb

@@ -0,0 +1,72 @@
+module Pandemic
+  module ServerSide
+    class Request    
+      include Util
+      
+      @@request_count = MutexCounter.new
+      @@late_responses = MutexCounter.new
+      attr_reader :body
+      attr_accessor :max_responses
+      
+      def self.total_request_count
+        @@request_count.real_total
+      end
+      
+      def self.total_late_responses
+        @@late_responses.real_total
+      end
+      
+      def initialize(body)
+        @request_number = @@request_count.inc
+        @body = body
+        @responses = []
+        @responses_mutex = Mutex.new
+        @complete = false
+      end
+    
+      def add_response(response)
+        @responses_mutex.synchronize do
+          if @responses.frozen? # too late
+            @@late_responses.inc
+            return  
+          end
+          debug("Adding response")
+          @responses << response
+          if @max_responses && @responses.size >= @max_responses
+            debug("Hit max responses, waking up waiting thread")
+            @waiting_thread.wakeup if @waiting_thread && @waiting_thread.status == "sleep"
+            @complete = true
+          end
+        end
+      end
+    
+      def responses
+        @responses # its frozen so we don't have to worry about mutex
+      end
+    
+      def wait_for_responses
+        return if @complete
+        @waiting_thread = Thread.current
+        sleep Config.response_timeout
+        # there is a race case where if the sleep finishes, 
+        # and response comes in and has the mutex, and then array is frozen
+        # it would be ideal to use monitor wait/signal here but the monitor implementation is currently flawed
+        @responses_mutex.synchronize { @responses.freeze }
+        @waiting_thread = nil
+      end
+      
+      def hash
+        @hash ||= Digest::MD5.hexdigest("#{@request_number} #{@body}")[0,10]
+      end
+      
+      private
+      def debug(msg)
+        logger.debug("Request #{hash}") {msg}
+      end
+      
+      def info(msg)
+        logger.info("Request #{hash}") {msg}
+      end
+    end
+  end
+end