pandemic 0.5.4

data/lib/pandemic/mutex_counter.rb

@@ -0,0 +1,50 @@
+module Pandemic
+  class MutexCounter
+    MAX = (2 ** 30) - 1
+    def initialize(max = MAX)
+      @mutex = Mutex.new
+      @counter = 0
+      @resets = 0
+      @max = max
+    end
+
+    def real_total
+      @mutex.synchronize { (@resets * @max) + @counter }
+    end
+    alias_method :to_i, :real_total
+    
+    def value
+      @mutex.synchronize { @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
+    alias_method :next, :inc
+    alias_method :succ, :inc
+    
+    # decr only to zero
+    def decr
+      @mutex.synchronize do
+        if @counter > 0
+          @counter -= 1
+        else
+          if @resets > 1
+            @resets -= 1 
+            @counter = @max
+          end
+        end
+        @counter
+      end
+    end
+    alias_method :pred, :decr
+    alias_method :prev, :decr
+    
+  end
+end

data/lib/pandemic/requests_per_second.rb

@@ -0,0 +1,31 @@
+module Pandemic
+  class RequestsPerSecond
+    def initialize(sample_size = 10)
+      @hits = Array.new(sample_size + 2)
+      @last_hit_at = nil
+    end
+
+    def hit(now = Time.now.to_i)
+      key = now % @hits.size
+      if @hits[key].nil? || @hits[key][0] != now
+        @hits[key] = [now, 0]
+      end
+      @hits[key][1] += 1
+      @last_hit_at = now
+    end
+
+    def rps(now = Time.now.to_i)
+      return 0 if @last_hit_at.nil?
+      entries_to_go_back = @hits.size - (now - @last_hit_at) - 2
+      return 0 if entries_to_go_back <= 0
+      sum = 0
+      entries_to_go_back.times do |i|
+        now -= 1 
+        if @hits[now % @hits.size] && @hits[now % @hits.size][0] == now
+          sum += @hits[now % @hits.size][1] 
+        end
+      end
+      return sum.to_f / (@hits.size - 2)
+    end
+  end
+end

data/lib/pandemic/server_side/client.rb

@@ -0,0 +1,123 @@
+module Pandemic
+  module ServerSide
+    class Client
+      REQUEST_FLAGS = {:async => 'a'}
+      EMPTY_STRING = ""
+      REQUEST_REGEXP = /^([0-9]+)(?: ([#{REQUEST_FLAGS.values.join('')}]*))?$/
+      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 = MutexCounter.new                                                             
+        @current_request = nil
+      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! =~ REQUEST_REGEXP
+                  size, flags = $1.to_i, $2.to_s.split(EMPTY_STRING)
+                  # debug("Reading request body (size #{size})")
+                  body = @connection.read(size)
+                  # debug("Finished reading request body")
+                  if flags.include?(REQUEST_FLAGS[:async])
+                    Thread.new do
+                      handle_request(body)
+                      @responded_requests.inc
+                    end
+                  else
+                    response = handle_request(body)
+                    if response
+                      # debug("Writing response to client")
+
+                      # the connection could be closed, we'll let it be rescued if it is.
+                      @connection.write("#{response.size}\n#{response}")
+                      @connection.flush
+                      # debug("Finished writing response to client")
+                    else
+                      # debug("Writing error code to client")
+                      
+                      @connection.write("-1\n")
+                      @connection.flush
+                      # debug("Finished writing error code to client")
+                    end
+                    @responded_requests.inc
+                  end
+                end
+              end
+            rescue DisconnectClient
+              info("Closing client connection")
+              close_connection
+            rescue Errno::EPIPE
+              info("Connection to client lost")
+              close_connection
+            rescue Exception => e
+              warn("Unhandled exception in client listen thread:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+            ensure
+              @current_request.cancel! if @current_request
+              @server.client_closed(self)
+            end
+          end
+        end
+        return self
+      end
+    
+      def close
+        @listener_thread.raise(DisconnectClient)
+      end
+      
+
+    
+      def handle_request(request)
+        @current_request = Request.new(request)
+        response = begin
+          @server.handle_client_request(@current_request)
+        rescue Exception => e
+          warn("Unhandled exception in handle client request:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+          nil
+        end
+        @current_request = nil
+        return response
+      end
+      
+      private
+      def close_connection
+        @connection.close unless @connection.nil? || @connection.closed?
+      end
+      
+      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,74 @@
+module Pandemic
+  module ServerSide
+    class Config
+      class << self
+        attr_accessor :bind_to, :servers, :response_timeout, :fork_for_processor, :pid_file
+        def load
+          parse_args!
+          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 parse_args!
+          config_path = "pandemic_server.yml"
+          index = nil
+          attach = nil
+          
+          @bind_to = nil
+          @pid_file = nil
+          OptionParser.new do |opts|
+            opts.on("-c", "--config [CONFIG-PATH]", "Specify the path to the config file") do |path|
+              config_path = path
+            end
+            
+            opts.on("-i", "--index [SERVER-INDEX]", "Specify the index of the server to attach to from the YAML file") do |i|
+              index = i
+            end
+
+            opts.on("-a", "--attach [SERVER:PORT]", "Specify the host and port to attach to") do |a|
+              attach = a
+            end
+            
+            opts.on("-P", "--pid-file [PATH]", "Specify the path to write the PID to") do |path|
+              @pid_file = path
+            end
+          end.parse!
+          
+          read_config_file(config_path)
+          
+          if index
+            index = index.to_i if @server_map.is_a?(Array)
+            server = @server_map[index]
+            
+            @bind_to = if server.is_a?(Hash)
+              @options = server.values.first # there should only be one
+              @server_map[index].keys.first
+            else
+              server
+            end
+          elsif attach
+            @bind_to = attach
+          end
+          
+        end
+        
+        def read_config_file(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
+
+          @fork_for_processor = yaml['fork_for_processor']
+        end
+      end
+    end
+  end
+end

data/lib/pandemic/server_side/handler.rb

@@ -0,0 +1,31 @@
+module Pandemic
+  module ServerSide
+    class Handler
+      def config
+        Config
+      end
+      
+      def partition(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
+      
+      def filter_alive(servers)
+        servers.keys.select{|k| servers[k] != :disconnected}
+      end        
+    end
+  end
+end

data/lib/pandemic/server_side/peer.rb

@@ -0,0 +1,211 @@
+module Pandemic
+  module ServerSide
+    class Peer
+      class PeerUnavailableException < StandardError; 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
+        # debug("Forced connection to peer")
+        @connection_pool.connect
+      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")
+        # debug("Connection pool has #{@connection_pool.available_count} of #{@connection_pool.connections_count} connections available")
+
+        successful = true
+        @pending_requests.synchronize do
+          @pending_requests[request.hash] = request
+        end
+        begin
+          @connection_pool.with_connection do |connection|
+            if connection && !connection.closed?
+              # debug("Writing client's request")
+              connection.write("P#{request.hash}#{[body.size].pack('N')}#{body}")
+              connection.flush
+              # debug("Finished writing client's request")
+            else
+              successful = false
+            end
+          end
+        rescue Exception
+          @pending_requests.synchronize { @pending_requests.delete(request.hash) }
+          raise
+        else
+          if !successful
+            @pending_requests.synchronize { @pending_requests.delete(request.hash) }
+          end
+        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.read(15)
+              # 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 =~ /^P/
+                handle_incoming_response(request, connection) if request =~ /^R/
+              end
+            end
+          rescue Exception => e
+            warn("Unhandled exception in peer listener thread:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+          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(:connect_at_define => false)
+        
+        @connection_pool.create_connection do
+          connection = nil
+          retries = 0
+          begin
+            connection = TCPSocket.new(@host, @port)
+          rescue Errno::ETIMEDOUT, Errno::ECONNREFUSED => e
+            connection = nil
+            # debug("Connection timeout or refused: #{e.inspect}")
+            if retries == 0
+              # debug("Retrying connection")
+              retries += 1
+              sleep 0.01
+              retry
+            end
+          rescue Exception => e
+            warn("Unhandled exception in create connection block:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+          end
+          if connection
+            connection.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if TCP_NO_DELAY_AVAILABLE
+            connection.write("SERVER #{@server.signature}\n")
+          end
+          connection
+        end
+      end
+    
+      def handle_incoming_request(request, connection)
+        # debug("Identified as request")
+        hash = request[1,10]
+        size = request[11, 4].unpack('N').first
+        # 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:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+        end
+        # debug("Processing body")
+        process_request(hash, request_body)
+      end
+    
+      def handle_incoming_response(response, connection)
+        hash = response[1,10]
+        size = response[11, 4].unpack('N').first
+        # 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:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+        end
+        process_response(hash, response_body)
+      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("R#{hash}#{[response.size].pack('N')}#{response}")
+              connection.flush
+              # debug( "Finished sending response (#{hash})")
+            end
+          rescue Exception => e
+            warn("Unhandled exception in process request thread:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+          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:\n#{e.inspect}\n#{e.backtrace.join("\n")}")
+          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