pandemic 0.5.4

data/lib/pandemic/util.rb

@@ -0,0 +1,15 @@
+module Pandemic
+  module Util
+    def host_port(str)
+      [str[/^[^:]+/], str[/[0-9]+$/].to_i]
+    end
+    
+    def logger
+      $pandemic_logger
+    end
+    
+    def with_mutex(obj)
+      obj.extend(MonitorMixin)
+    end
+  end
+end

data/pandemic.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pandemic}
+  s.version = "0.5.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Arya Asemanfar"]
+  s.date = %q{2009-09-07}
+  s.description = %q{A framework for distributing work for real-time services and offline tasks.}
+  s.email = %q{aryaasemanfar@gmail.com}
+  s.extra_rdoc_files = ["lib/pandemic/client_side/cluster_connection.rb", "lib/pandemic/client_side/config.rb", "lib/pandemic/client_side/connection.rb", "lib/pandemic/client_side/connection_proxy.rb", "lib/pandemic/client_side/pandemize.rb", "lib/pandemic/connection_pool.rb", "lib/pandemic/mutex_counter.rb", "lib/pandemic/requests_per_second.rb", "lib/pandemic/server_side/client.rb", "lib/pandemic/server_side/config.rb", "lib/pandemic/server_side/handler.rb", "lib/pandemic/server_side/peer.rb", "lib/pandemic/server_side/processor.rb", "lib/pandemic/server_side/request.rb", "lib/pandemic/server_side/server.rb", "lib/pandemic/util.rb", "lib/pandemic.rb", "README.markdown"]
+  s.files = ["examples/client/client.rb", "examples/client/constitution.txt", "examples/client/pandemic_client.yml", "examples/server/pandemic_server.yml", "examples/server/word_count_server.rb", "lib/pandemic/client_side/cluster_connection.rb", "lib/pandemic/client_side/config.rb", "lib/pandemic/client_side/connection.rb", "lib/pandemic/client_side/connection_proxy.rb", "lib/pandemic/client_side/pandemize.rb", "lib/pandemic/connection_pool.rb", "lib/pandemic/mutex_counter.rb", "lib/pandemic/requests_per_second.rb", "lib/pandemic/server_side/client.rb", "lib/pandemic/server_side/config.rb", "lib/pandemic/server_side/handler.rb", "lib/pandemic/server_side/peer.rb", "lib/pandemic/server_side/processor.rb", "lib/pandemic/server_side/request.rb", "lib/pandemic/server_side/server.rb", "lib/pandemic/util.rb", "lib/pandemic.rb", "Manifest", "MIT-LICENSE", "pandemic.gemspec", "Rakefile", "README.markdown", "test/client_test.rb", "test/connection_pool_test.rb", "test/functional_test.rb", "test/handler_test.rb", "test/mutex_counter_test.rb", "test/peer_test.rb", "test/processor_test.rb", "test/server_test.rb", "test/test_helper.rb", "test/util_test.rb"]
+  s.homepage = %q{https://github.com/arya/pandemic/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Pandemic", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pandemic}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{A framework for distributing work for real-time services and offline tasks.}
+  s.test_files = ["test/client_test.rb", "test/connection_pool_test.rb", "test/functional_test.rb", "test/handler_test.rb", "test/mutex_counter_test.rb", "test/peer_test.rb", "test/processor_test.rb", "test/server_test.rb", "test/test_helper.rb", "test/util_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class ClientTest < Test::Unit::TestCase
+  include TestHelper
+  
+  context "with a client object" do
+    setup do
+      @server = mock()
+      @server.stubs(:client_closed)
+      @server.stubs(:handle_client_request)
+      @server.expects(:running).at_least_once.returns(true).then.returns(false)
+      @connection = mock()
+      @connection.stubs(:write)
+      @connection.stubs(:flush)
+      @connection.stubs(:peeraddr).returns(['','','',''])
+      @connection.expects(:nil?).returns(false).at_least_once
+      @client = Pandemic::ServerSide::Client.new(@connection, @server)
+    end
+    
+    should "read size from the connection" do
+      @connection.expects(:gets).returns("5\n")
+      @connection.expects(:read).with(5)
+      @server.expects(:client_closed).with(@client)
+      @client.listen
+      wait_for_threads
+    end
+    
+    should "read body from the connection" do
+      @connection.expects(:gets).returns("5\n")
+      @connection.expects(:read).with(5).returns("hello")
+      @server.expects(:client_closed).with(@client)
+      @client.listen    
+      wait_for_threads
+    end
+    
+    should "call handle request body on server" do
+      @connection.expects(:gets).returns("5\n")
+      @connection.expects(:read).with(5).returns("hello")
+      
+      request = mock()
+      Pandemic::ServerSide::Request.expects(:new).returns(request)
+      @server.expects(:handle_client_request).with(request).returns(nil)
+      @connection.stubs(:write)
+      @connection.stubs(:flush)
+      
+      @server.expects(:client_closed).with(@client)
+      @client.listen    
+      wait_for_threads
+    end
+    
+    should "write response back to client" do
+      @connection.expects(:gets).returns("5\n")
+      @connection.expects(:read).with(5).returns("hello")
+      
+      request = mock()
+      response = "olleh"
+      Pandemic::ServerSide::Request.expects(:new).returns(request)
+      @server.expects(:handle_client_request).with(request).returns(response)
+      
+      @connection.expects(:write).with("5\n#{response}")
+      @connection.expects(:flush)
+      
+      @server.expects(:client_closed).with(@client)
+      @client.listen    
+      wait_for_threads
+    end
+    
+    should "close the connection on nil response" do
+      @connection.expects(:gets).returns(nil)
+      @connection.expects(:close)
+      
+      @server.expects(:client_closed).with(@client)
+      @client.listen
+      wait_for_threads
+    end
+    
+    should "close the connection on disconnect" do
+      @connection.expects(:gets).raises(Pandemic::ServerSide::Client::DisconnectClient)
+      @connection.expects(:closed?).returns(false)
+      @connection.expects(:close)
+      
+      @server.expects(:client_closed).with(@client)
+      @client.listen
+      wait_for_threads
+    end
+  end
+end

data/test/connection_pool_test.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+
+class ConnectionPoolTest < Test::Unit::TestCase
+  include TestHelper
+  context "without a create connection block" do
+    setup do
+      @connection_pool = Pandemic::ConnectionPool.new
+    end
+    
+    should "raise an exception when trying to connect" do
+      assert_raises Pandemic::ConnectionPool::CreateConnectionUndefinedException do
+        @connection_pool.connect
+      end
+    end
+  end
+  
+  context "with a connection pool" do
+    setup do
+      @connection_pool = Pandemic::ConnectionPool.new
+      @connection_creator = mock()
+      @connection_destroyer = mock()
+    end
+    
+    should "call create connection after its defined" do
+      @connection_creator.expects(:create).once
+      @connection_pool.create_connection do
+        @connection_creator.create
+      end
+    end
+    
+    should "call destroyer on disconnect" do
+      @connection_creator.expects(:create).once
+      @connection_destroyer.expects(:destroy).once
+      @connection_pool.create_connection do
+        @connection_creator.create
+        conn = mock()
+        conn.expects(:closed?).returns(false).at_least(0)
+        conn
+      end
+      
+      @connection_pool.destroy_connection do
+        @connection_destroyer.destroy
+      end
+      
+      @connection_pool.disconnect
+    end
+    
+  end
+  
+  context "with a max connections of 2" do
+    setup do
+      @connection_pool = Pandemic::ConnectionPool.new(:max_connections => 2, :timeout => 0.01)
+      @connection_creator = mock()
+    end
+    
+    should "raise timeout exception when no connections available" do
+      @connection_creator.expects(:create).twice
+      @connection_pool.create_connection do
+        @connection_creator.create
+        conn = mock()
+        conn.expects(:closed?).returns(false).at_least(0)
+        conn
+      end
+      
+      assert_raises Pandemic::ConnectionPool::TimedOutWaitingForConnectionException do
+        @connection_pool.with_connection do |conn1|
+          @connection_pool.with_connection do |conn2|
+            @connection_pool.with_connection do |conn3|
+              fail("there should only be two connections")
+            end
+          end
+        end
+      end
+    end
+    
+    should "should checkin a connection and allow someone check the same one out" do
+      @connection_creator.expects(:create).twice
+      @connection_pool.create_connection do
+        @connection_creator.create
+        conn = mock()
+        conn.expects(:closed?).returns(false).at_least(0)
+        conn
+      end
+      
+      @connection_pool.with_connection do |conn1|
+        conn2, conn3 = nil, nil
+        
+        @connection_pool.with_connection do |conn|
+          conn2 = conn
+        end
+        @connection_pool.with_connection do |conn|
+          conn3 = conn
+        end
+        
+        assert_equal conn2, conn3
+      end
+    end
+    
+    should "should checkin connection even if there is an exception" do
+      @connection_creator.expects(:create).once
+      @connection_pool.create_connection do
+        @connection_creator.create
+        conn = mock()
+        conn.expects(:closed?).returns(false).at_least(0)
+        conn
+      end
+      before = @connection_pool.available_count
+      begin
+        @connection_pool.with_connection do |conn1|
+          raise TestException
+        end
+      rescue TestException
+      end
+      after = @connection_pool.available_count
+      
+      assert_equal before, after
+    end
+  end
+  
+  context "with a min connections of 2" do
+    setup do
+      @connection_pool = Pandemic::ConnectionPool.new(:min_connections => 2)
+      @connection_creator = mock()
+    end
+    
+    should "call create connection twice" do
+      @connection_creator.expects(:create).twice
+      @connection_pool.create_connection do
+        @connection_creator.create
+      end
+    end
+  end
+end

data/test/functional_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class FunctionalTest < Test::Unit::TestCase
+  include TestHelper
+  should "work" do
+    ignore_threads = Thread.list
+    ARGV.replace(["-i", "0", "-c", "test/pandemic_server.yml"]) # :(
+    Pandemic::ClientSide::Config.config_path = "test/pandemic_client.yml"
+    server = epidemic!
+    server.handler = Class.new(Pandemic::ServerSide::Handler) do
+      def process(body)
+        body.reverse
+      end
+    end
+    server.start
+    
+    client = Class.new do
+      include Pandemize
+    end.new
+    client.extend(Pandemize)
+    assert_equal "dlrow olleh", client.pandemic.request("hello world")
+    client.pandemic.shutdown
+    server.stop
+    wait_for_threads(ignore_threads)
+  end
+  
+  should "work with multiple peers" do
+    ignore_threads = Thread.list
+    handler = Class.new(Pandemic::ServerSide::Handler) do
+      def process(body)
+        body.reverse
+      end
+    end
+    
+    ARGV.replace(["-i", "0", "-c", "test/pandemic_server.yml"]) # :(    
+    server = epidemic!
+    server.handler = handler
+    server.start
+    
+    ARGV.replace(["-i", "1", "-c", "test/pandemic_server.yml"]) # :(    
+    server2 = epidemic!
+    server2.handler = handler
+    server2.start
+    
+    Pandemic::ClientSide::Config.config_path = "test/pandemic_client.yml"
+    
+    client = Class.new do
+      include Pandemize
+    end.new
+    client.extend(Pandemize)
+    assert_equal "raboofraboof", client.pandemic.request("foobar")
+    client.pandemic.shutdown
+    server.stop
+    server2.stop
+    wait_for_threads(ignore_threads)
+  end
+end

data/test/handler_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class HandlerTest < Test::Unit::TestCase
+  include TestHelper
+  
+  context "with a request object" do
+    setup do
+      @request = mock()
+      @servers = {
+        1 => :self,
+        2 => :disconnected,
+        3 => :connected
+      }
+      @handler = Pandemic::ServerSide::Handler.new
+    end
+    
+    should "concatenate all the results" do
+      @request.expects(:responses).once.returns(%w{1 2 3})
+      assert_equal "123", @handler.reduce(@request)
+    end
+    
+    should "map to all non-disconnected nodes" do
+      @request.expects(:body).twice.returns("123")
+      map = @handler.partition(@request, @servers)
+      # see setup for @servers
+      assert_equal 2, map.size
+      assert_equal "123", map[1]
+      assert_equal "123", map[3]
+    end
+  end
+end

data/test/mutex_counter_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class MutexCounterTest < Test::Unit::TestCase
+  context "with a new counter" do 
+    setup do
+      @counter = Pandemic::MutexCounter.new
+    end
+
+    should "start at 0" do
+      assert_equal 0, @counter.value
+    end
+
+    should "increment to 1 after one call to inc" do
+      assert_equal 0, @counter.value
+      assert_equal 1, @counter.inc
+      assert_equal 1, @counter.value
+    end
+    
+    should "decrement to 0 after one call to inc" do
+      assert_equal 0, @counter.value
+      assert_equal 1, @counter.inc
+      assert_equal 1, @counter.value
+      assert_equal 0, @counter.decr
+      assert_equal 0, @counter.value
+    end
+    
+    should "only decrement to 0" do
+      assert_equal 0, @counter.value
+      assert_equal 1, @counter.inc
+      assert_equal 1, @counter.value
+      assert_equal 0, @counter.decr
+      assert_equal 0, @counter.value
+      assert_equal 0, @counter.decr
+      assert_equal 0, @counter.value
+    end
+    
+    should "be thread safe" do
+      # Not exactly a perfect test, but I'm not sure how to actually test 
+      # this without putting some code in the counter for this reason.
+      threads = []
+      5.times { threads << Thread.new { 100.times { @counter.inc }}}
+      threads.each {|t| t.join } # make sure they're all done
+      assert_equal 500, @counter.value
+    end
+  end
+    
+  context "with a max of 10" do
+    setup do
+      @counter = Pandemic::MutexCounter.new(10)
+    end
+    
+    should "cycle from 1 to 10" do
+      expected = (1..10).to_a + [1]
+      actual = (1..11).collect { @counter.inc }
+      assert_equal expected, actual
+    end
+    
+    should "have the correct 'real_total'" do
+      11.times { @counter.inc }
+      assert_equal 1, @counter.value
+      assert_equal 11, @counter.real_total
+    end
+    
+    should "maintain correct 'real_total' with decrement" do
+      11.times { @counter.inc }
+      assert_equal 1, @counter.value
+      assert_equal 11, @counter.real_total
+      assert_equal 0, @counter.decr
+      assert_equal 10, @counter.real_total
+    end
+    
+  end
+end

data/test/peer_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class PeerTest < Test::Unit::TestCase
+  include TestHelper
+  
+  should "initialize a new connection pool" do
+    connection_pool = mock()
+    Pandemic::ConnectionPool.expects(:new).returns(connection_pool)
+    connection_pool.expects(:create_connection)
+    
+    server = mock()
+    peer = Pandemic::ServerSide::Peer.new("localhost:4000", server)
+  end
+  
+  should "create a tcp socket" do
+    connection_pool = mock()
+    Pandemic::ConnectionPool.expects(:new).returns(connection_pool)
+    connection_pool.expects(:create_connection).yields
+    TCPSocket.expects(:new).with("localhost", 4000)
+    
+    server = mock()
+    peer = Pandemic::ServerSide::Peer.new("localhost:4000", server)
+  end
+  
+  context "with conn. pool" do
+    setup do
+      @connection_pool = mock()
+      Pandemic::ConnectionPool.expects(:new).returns(@connection_pool)
+      @connection_pool.expects(:create_connection)
+
+      @server = mock()
+      @peer = Pandemic::ServerSide::Peer.new("localhost:4000", @server)
+    end
+    
+    should "send client request to peer connection" do
+      request, body = stub(:hash => "asdasdfadsf"), "hello world"
+      @connection_pool.stubs(:available_count => 1, :connections_count => 1)
+      conn = mock()
+      @connection_pool.expects(:with_connection).yields(conn)
+      
+      conn.stubs(:closed? => false)
+      conn.expects(:write).with("P#{request.hash}#{[body.size].pack('N')}#{body}")
+      conn.expects(:flush)
+      
+      @peer.client_request(request, body)
+    end
+  end
+end