who_can 0.3.5 → 0.4.0.beta.1

data/Rakefile

@@ -1,2 +1,11 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+task :environment do
+  Bundler.require(:default, :development)
+end
+
+task :draw do
+  ruby %Q[-r 'bundler/setup' -r who_can -e 'WhoCan::ConnectionManager.state_machines[:state].draw']
+end
+

data/lib/who_can/base.rb

@@ -25,7 +25,10 @@ module WhoCan
     alias :connect! :connection
 
     def on_open(&block)
-      connection.on_open(&block)
+      Deferred::Default.new.tap do |my_dfr|
+        my_dfr.callback(&block) if block
+        connection.on_open { |*a| my_dfr.succeed(*a) }
+      end
     end
 
     def start_monitoring!(opts = {})
@@ -37,6 +40,10 @@ module WhoCan
       @ekg.start!
     end
 
+    def monitoring?
+      false|@ekg.running?
+    end
+
     def new_pinger
       WhoCan::Pinger.new(connection)
     end
@@ -67,6 +74,14 @@ module WhoCan
       end
       false
     end
+
+    def to_async
+      self
+    end
+
+    def to_synchrony
+      WhoCan::Synchrony::Base.new(self)
+    end
   end
 end
 

data/lib/who_can/connection_manager.rb

@@ -95,23 +95,23 @@ module WhoCan
       # the primary has connected within the grace period, enter the connected state
       after_transition :awaiting_primary => :connected,   :do => :become_usable!
 
-      #make sure we are up as soon as possible - don't wait for the secondary
+      # make sure we are up as soon as possible - don't wait for the secondary
       after_transition :start_up => :degraded, :do => :become_usable!
 
-      #primary has returned
+      # primary has returned
       after_transition :failed_over => :connected, :do => [:fire_failure_deferred, :become_usable!]
 
       # the primary fails, secondary is available
       after_transition :connected => :failed_over, :do => [:fire_failure_deferred, :enter_failed_over_state, :do_connect_primary]
 
-      #the two states we can be in when the secondary is going down
+      # the two states we can be in when the secondary is going down
       after_transition :failed_over => :down, :do => [:fire_failure_deferred, :do_connect_secondary]
       after_transition :connected => :degraded, :do => :do_connect_secondary
 
-      #primary went down, and secondary was already down
+      # primary went down, and secondary was already down
       after_transition :degraded => :down, :do => [:fire_failure_deferred, :do_connect_primary, :do_connect_secondary]
 
-      #we've been down, now we're coming back up
+      # we've been down, now we're coming back up
       after_transition :down => :failed_over, :do => :enter_failed_over_state
       after_transition :down => :degraded, :do => :become_usable!
 
@@ -208,6 +208,14 @@ module WhoCan
 
     alias :useable? :usable?
 
+    def to_async
+      self
+    end
+
+    def to_synchrony
+      Synchrony::ConnectionManager.new(self)
+    end
+
     protected
       def do_connect_primary
         @primary.on_failure { primary_failed }

data/lib/who_can/heartbeater/ekg.rb

@@ -11,6 +11,8 @@ module WhoCan
       include Logging
       include Deferred
 
+      CHANNEL_SHUTDOWN_TIMEOUT = 0.1
+
       attr_reader :connection, :queue, :interval, :max_failures, :failure_count
 
       # fired when the amqp channel has opened and we've started sending beats
@@ -46,6 +48,10 @@ module WhoCan
         @outstanding_beats = {}
       end
 
+      def running?
+        false|@running
+      end
+
       def channel
         @channel ||= AMQP::Channel.new(connection)
       end
@@ -84,22 +90,20 @@ module WhoCan
         return on_shutdown unless @running
         @running = false
 
-        logger.debug { "performing shutdown!" }
-
         @queue.unsubscribe if @queue
 
         @timer.cancel if @timer
 
-        close_failsafe_timer = EM::Timer.new(1.0) do
-          logger.warn { "channel.close never called its block, probably hung. calling on_shutdown.succeed" }
+        timeout = EM::Timer.new(CHANNEL_SHUTDOWN_TIMEOUT) do
+          logger.debug { "channel shutdown has timed out" }
           on_shutdown.succeed
         end
 
-        @channel.close {
-          close_failsafe_timer.cancel
-          logger.debug { "channel has closed!" }
+        @channel.close do
+          logger.debug { "channel has closed, cancelling timeout" }
+          timeout.cancel
           on_shutdown.succeed 
-        }
+        end
 
         on_shutdown
       rescue AMQ::Client::ConnectionClosedError

data/lib/who_can/pinger.rb

@@ -15,8 +15,12 @@ module WhoCan
       @connection = connection
       @needs_reply = {}
       @queue = nil
+      @started = false
     end
 
+    def started?
+      false|@started
+    end
    
     def start!(&blk)
       EM.schedule do
@@ -34,6 +38,7 @@ module WhoCan
             @queue = q
             block_callback = lambda do |*args|
               logger.debug {"calling back to with_queue"}
+              @started = true
               on_start.succeed
             end
 
@@ -51,18 +56,23 @@ module WhoCan
     def ping!(exchange, timeout=5, &callback)
       logger.debug { "sending a ping to #{exchange}" }
       deferred = Deferred::Default.new
+
       deferred.callback(&callback)
-      deferred.timeout(timeout)
+      deferred.timeout(timeout, WhoCan::TimeoutError)
+
       raise "Channel not opened" unless channel.open?
-        msg_id = self.class.create_msg_id
-        @needs_reply[msg_id] = deferred
-        
-        deferred.errback_on_exception do
-          logger.debug {"sending the ping to #{exchange} with a reply to of #{@queue.name}"}
-          # XXX: the block given to publish here appears to be a bug w/ amqp gem, without it an exception is raised
-          ping_exchange = channel.fanout(exchange)
-          ping_exchange.publish('PING', :reply_to => @queue.name, :message_id => msg_id) { logger.debug { "actually sent the ping to #{exchange}" } }
-        end
+
+      msg_id = self.class.create_msg_id
+      @needs_reply[msg_id] = deferred
+
+      deferred.errback_on_exception do
+        logger.debug {"sending the ping to #{exchange} with a reply to of #{@queue.name}"}
+        # XXX: the block given to publish here appears to be a bug w/ amqp gem, without it an exception is raised
+
+        ping_exchange = channel.fanout(exchange)
+        ping_exchange.publish('PING', :reply_to => @queue.name, :message_id => msg_id) { logger.debug { "actually sent the ping to #{exchange}" } }
+      end
+
       deferred
     rescue Exception => e
       logger.error {"received an exception on ping!: #{e.to_std_format}"}
@@ -70,13 +80,22 @@ module WhoCan
       deferred
     end
 
-    def handle_response(header, payload)
-      logger.debug {"handling a response (#{header.message_id}) with a payload of: #{payload}"}
-      if deferred = @needs_reply.delete(header.message_id)
-        EM.schedule do
-          deferred.succeed(header, payload)
+    def to_synchrony
+      WhoCan::Synchrony::Pinger.new(self)
+    end
+
+    def to_async
+      self
+    end
+
+    private
+      def handle_response(header, payload)
+        logger.debug {"handling a response (#{header.message_id}) with a payload of: #{payload}"}
+        if deferred = @needs_reply.delete(header.message_id)
+          EM.schedule do
+            deferred.succeed(header, payload)
+          end
         end
       end
-    end
   end
 end

data/lib/who_can/responder.rb

@@ -41,6 +41,7 @@ module WhoCan
       @ping_exchange_name = ping_exchange_name
       @on_ping_cb = nil
       @set_up = false
+      @started = false
     end
 
     # wc = WhoCan.new(connection_opts)
@@ -77,10 +78,11 @@ module WhoCan
 
         unless @close_requested
           @queue.bind(@ping_exchange) do
-            #logger.debug {"subscribing to the #{@ping_exchange_name}"}
+            logger.debug {"subscribing to the #{@ping_exchange_name}"}
 
             confirm_queue = lambda do |*a|
-              #logger.debug { "queue subscribed to #{@ping_exchange_name}" }
+              logger.debug { "queue subscribed to #{@ping_exchange_name}" }
+              @started = true
               on_start.succeed
             end
 
@@ -91,6 +93,10 @@ module WhoCan
       on_start
     end
 
+    def started?
+      false|@started
+    end
+
     def handle_message(header, payload)
       if @on_ping_cb
         resp = Response.new(header, payload)
@@ -116,6 +122,7 @@ module WhoCan
 
       @queue.unsubscribe if @queue
       @queue = nil
+      @started = false
       @set_up = false
     end
 
@@ -124,6 +131,14 @@ module WhoCan
     def on_ping(&block)
       @on_ping_cb = block
     end
+
+    def to_synchrony
+      WhoCan::Synchrony::Responder.new(self)
+    end
+
+    def to_async
+      self
+    end
   end
 end
 

data/lib/who_can/synchrony/base.rb

@@ -0,0 +1,57 @@
+module WhoCan
+  module Synchrony
+    class Base
+      include Logging
+
+      def initialize(connection_opts=nil)
+        case connection_opts
+        when WhoCan::Base
+          @base = connection_opts
+        else
+          @base = WhoCan::Base.new(connection_opts)
+        end
+      end
+
+      def connect!
+        @base.connect!
+        wait_for_open
+      end
+
+      # this can be used instead of on_open to wait for the connection
+      # to be in an opened state before proceeding
+      def wait_for_open
+        Synchrony.sync!(@base.on_open)
+      end
+
+      def start_monitoring!(opts={})
+        Synchrony.sync!(@base.start_monitoring!(opts))
+      end
+
+      def close!
+        Synchrony.sync!(@base.close!)
+      end
+
+      def new_pinger
+        WhoCan::Synchrony::Pinger.new(@base.connection)
+      end
+
+      def new_responder(exchange_name)
+        WhoCan::Synchrony::Responder.new(@base.connection, exchange_name)
+      end
+
+      def to_async
+        @base
+      end
+
+      def to_synchrony
+        self
+      end
+
+      private
+        def method_missing(m, *a, &b)
+          @base.__send__(m, *a, &b)
+        end
+    end
+  end
+end
+

data/lib/who_can/synchrony/connection_manager.rb

@@ -0,0 +1,52 @@
+module WhoCan
+  module Synchrony
+    class ConnectionManager
+      include Logging
+
+      def initialize(*args)
+        if (2..3).include?(args.length)
+          @cm = WhoCan::ConnectionManager.new(*args)
+        elsif args.length == 1
+          @cm = args.first
+        else
+          raise ArgumentError, "Don't know how to deal with args: #{args.inspect}"
+        end
+      end
+
+      def start(*a)
+        @cm.start(*a)
+        Synchrony.sync!(@cm.on_open)
+      end
+
+      def start!(*a)
+        @cm.start!(*a)
+        Synchony.sync!(@cm.on_open)
+      end
+
+      def close(*a)
+        @cm.close(*a)
+        Synchrony.sync!(@cm.on_close)
+      end
+
+      def close!(*a)
+        @cm.close!(*a)
+        Synchrony.sync!(@cm.on_close)
+      end
+
+      def to_synchrony
+        self
+      end
+
+      # returns async ConnectionManager instance
+      def to_async
+        @cm
+      end
+
+      private
+        def method_missing(m, *a, &b)
+          @cm.__send__(m, *a, &b)
+        end
+    end
+  end
+end
+

data/lib/who_can/synchrony/pinger.rb

@@ -0,0 +1,37 @@
+module WhoCan
+  module Synchrony
+    class Pinger
+      def initialize(connection)
+        case connection
+        when WhoCan::Pinger
+          @pinger = connection
+        else
+          @pinger = WhoCan::Pinger.new(connection)
+        end
+      end
+
+      def start!
+        Synchrony.sync!(@pinger.start!)
+      end
+
+      # returns the header, paylod 
+      def ping!(*a, &b)
+        Synchrony.sync!(@pinger.ping!(*a, &b))
+      end
+
+      def to_async
+        @pinger
+      end
+
+      def to_synchrony
+        self
+      end
+
+      private
+        def method_missing(m, *a, &b)
+          @pinger.__send__(m, *a, &b)
+        end
+    end
+  end
+end
+

data/lib/who_can/synchrony/responder.rb

@@ -0,0 +1,36 @@
+module WhoCan
+  module Synchrony
+    class Responder
+      include Logging
+
+      def initialize(*args)
+        case args.length
+        when 2
+          @responder = WhoCan::Responder.new(*args)
+        when 1
+          @responder = args.first
+        else
+          raise ArgumentError, "bad args: #{args.inspect}"
+        end
+      end
+
+      def setup!
+        Synchrony.sync!(@responder.setup!)
+      end
+
+      def to_synchrony
+        self
+      end
+
+      def to_async
+        @responder
+      end
+
+      private
+        def method_missing(m, *a, &b)
+          @responder.__send__(m, *a, &b)
+        end
+    end
+  end
+end
+

data/lib/who_can/synchrony.rb

@@ -0,0 +1,54 @@
+module WhoCan
+  module Synchrony
+    extend Logging
+
+    def self.new(*a, &b)
+      WhoCan::Synchrony::Base.new(*a, &b)
+    end
+
+    module SyncMethods
+      # @private
+      # a modification of EM::Synchrony.sync to handle multiple callback arguments properly
+      def sync(df)
+        f = Fiber.current
+
+        xback = proc do |*args|
+          if f == Fiber.current
+            return *args
+          else
+            f.resume(*args)
+          end
+        end
+
+        df.callback(&xback)
+        df.errback(&xback)
+
+        Fiber.yield
+      end
+
+      # @private
+      # like sync, but if the deferred returns an exception instance, re-raises
+      def sync!(df)
+        rval = sync(df)
+
+        # XXX: arrgh, this is really gross...
+
+        if rval.kind_of?(Exception)
+          raise rval
+        elsif rval.respond_to?(:first) and rval.first.kind_of?(Exception)
+          raise rval.first
+        else
+          return rval
+        end
+      end
+    end
+
+    extend SyncMethods
+  end
+end
+
+require 'who_can/synchrony/connection_manager'
+require 'who_can/synchrony/pinger'
+require 'who_can/synchrony/responder'
+require 'who_can/synchrony/base'
+

data/lib/who_can/version.rb

@@ -1,3 +1,3 @@
 module WhoCan
-  VERSION = "0.3.5"
+  VERSION = "0.4.0.beta.1"
 end

data/lib/who_can.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'amqp'
 require 'state_machine'
 require 'uuidtools'
+require 'em-synchrony'
 require 'thread'
 require 'monitor'
 require 'logger'
@@ -60,5 +61,6 @@ require 'who_can/responder'
 require 'who_can/heartbeater'
 require 'who_can/connection_wrapper'
 require 'who_can/connection_manager'
+require 'who_can/synchrony'
 
 

data/spec/support/em_synchrony_spec.rb

@@ -0,0 +1,11 @@
+
+class ::Fiber
+  if method_defined?(:wrap)
+    raise "WTF?! Fiber.wrap exists?"
+  else
+    def self.wrap(&blk)
+      new { blk.call }.resume
+    end
+  end
+end
+

data/spec/who_can/base_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 
 module WhoCan
-
   describe "Base" do
     describe "using an existing connection" do
       include EventedSpec::AMQPSpec
@@ -55,12 +54,6 @@ module WhoCan
           heartbeat_failure_block.call
         end
       end
-
-
     end
-
-
-
   end
-
 end

data/spec/who_can/heartbeater/ekg_spec.rb

@@ -4,11 +4,11 @@ module WhoCan::Heartbeater
 
   describe "EKG" do
     include EventedSpec::AMQPSpec
-    include WhoCan::Logging
-
     default_timeout 3.0
     default_options :host => 'localhost'
 
+    let(:logger) { WhoCan.logger }
+
     amqp_before do
       @ekg = EKG.new(AMQP.connection, :interval => 0.2, :max_failures => 1, :timeout => 0.5)
     end
@@ -26,10 +26,10 @@ module WhoCan::Heartbeater
 
     it "should fire failure when there is a tcp connection loss" do
       @ekg.on_heartbeat_failure do
-        logger.debug {"heartbeat failure received"}
+#         logger.debug {"heartbeat failure received"}
 
         @ekg.shutdown! do
-          logger.debug { "on shutdown fired" }
+#           logger.debug { "on shutdown fired" }
           done
         end
       end

data/spec/who_can/responder_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
-
 module WhoCan
-
   describe "Responder" do
     include EventedSpec::AMQPSpec
     default_timeout 3.0
@@ -14,7 +12,6 @@ module WhoCan
       @responder = @who_can.new_responder(@exchange_name)
     end
 
-
     it "should respond to the pings" do
       @responder.on_ping do |response|
         response.delay = 0.1
@@ -37,12 +34,6 @@ module WhoCan
           end
         end
       end
-
-
-    end
-
-
+    end # it should respond to the pings
   end
-
-
 end

data/spec/who_can/synchrony/base_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module WhoCan
+  describe 'Base' do
+    describe 'using an existing connection' do
+      include EventedSpec::AMQPSpec
+      include Logging
+
+      default_timeout 3.0
+      default_options :host => 'localhost'
+
+      amqp_before do
+        @who_can = WhoCan::Synchrony.new(AMQP.connection)
+        @who_can.on_disconnection do
+          logger.debug { "on_disconnection called, calling done" }
+          done 
+        end
+      end
+
+      describe 'start_monitoring!' do
+        it %[should be monitoring after start_monitoring! returns] do
+          Fiber.wrap do
+            @who_can.start_monitoring!
+            logger.debug { "start_monitoring! returned" }
+
+            @who_can.should be_monitoring
+            logger.debug { "we are monitoring, now closing" }
+
+            @who_can.close!
+            logger.debug { "close returned" }
+          end
+        end
+      end
+
+      it %[should fire the on_disconnection when a tcp failure occurs] do
+        Fiber.wrap do
+          @who_can.start_monitoring!
+          AMQP.connection.tcp_connection_lost
+        end
+      end
+
+      it %[should should fire disconnection on close!] do
+        Fiber.wrap do
+          @who_can.wait_for_open
+          @who_can.close!
+        end
+      end
+
+      it %[should fire disconnection on heartbeat_failure] do
+        bogus_start_dfr = Deferred::Default.new.tap { |d| d.succeed }
+
+        heartbeat_failure_block = nil
+        fake_ekg = flexmock('ekg') do |m|
+          m.should_receive(:on_heartbeat_failure).with(Proc).and_return do |blk|
+            heartbeat_failure_block = blk
+          end
+          m.should_receive(:start!).and_return(bogus_start_dfr)
+        end
+
+        flexmock(Heartbeater::EKG).should_receive(:new).and_return(fake_ekg)
+
+        Fiber.wrap do
+          @who_can.start_monitoring!
+          @who_can.wait_for_open
+
+          heartbeat_failure_block.should_not be_nil
+          heartbeat_failure_block.call
+        end
+      end
+    end
+  end
+end
+

data/spec/who_can/synchrony/connection_manager_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module WhoCan
+  describe 'ConnectionManager' do
+    include EventedSpec::EMSpec
+    include Logging
+
+    default_timeout 3.0
+
+    em_before do
+      @connection1 = ConnectionWrapper.new("amqp://localhost")
+      @connection2 = ConnectionWrapper.new("amqp://localhost")
+      @connection_manager = WhoCan::Synchrony::ConnectionManager.new(@connection1, @connection2)
+    end
+
+    def clean_and_done
+      # logger.debug {"calling test done on next tick"}
+      EM.next_tick do
+        Fiber.wrap do
+          # logger.debug {"test done, closing"}
+          @connection_manager.close
+          done
+        end
+      end
+    end
+
+    def neuter_connection(connection)
+      flexmock(connection).should_receive(:connect).and_return true
+    end
+
+    describe "under totally normal circumstances" do
+      it "should enter a usable state after calling start" do
+        Fiber.wrap do
+          @connection_manager.start
+          @connection_manager.should be_usable
+          clean_and_done
+        end
+      end
+
+      it "should enter the degraded state if #2 never starts" do
+        neuter_connection(@connection2)
+
+        Fiber.wrap do
+          @connection_manager.start
+          @connection_manager.should be_degraded
+          clean_and_done
+        end
+      end
+
+      it "should be useable after grace period if only secondary starts up" do
+        neuter_connection(@connection1)
+
+        @connection_manager.primary_grace_time = 0.1
+
+        Fiber.wrap do
+          @connection_manager.start
+          @connection_manager.should be_failed_over
+          @connection_manager.should be_usable
+          clean_and_done
+        end
+      end
+    end
+  end
+end
+

data/spec/who_can/synchrony/pinger_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module WhoCan
+  class TestingError < StandardError; end
+
+  describe "Pinger" do
+    include EventedSpec::AMQPSpec
+    include Logging
+
+    default_timeout 3.0
+    default_options :host => 'localhost'
+
+    amqp_before do
+      @who_can = WhoCan::Synchrony.new(AMQP.connection) #default opts
+      @pinger = @who_can.new_pinger
+    end
+
+    it %[should call back with the responders info] do
+      exchange_name = "test_exchange"
+
+      call_pinger = lambda do
+        Fiber.wrap do
+          @pinger.start!
+          @pinger.should be_started
+
+          header, payload = @pinger.ping!(exchange_name)
+
+          logger.debug { "received response, payload: #{payload.inspect}" }
+          payload.should == "HAI"
+          done
+        end
+      end
+
+      AMQP::Channel.new do |channel|
+        channel.fanout(exchange_name) do |exchange|
+          channel.queue('', :exclusive => true, :auto_delete => true) do |queue|
+            queue.bind(exchange) do
+              queue.subscribe do |header, payload|
+                channel.default_exchange.publish("HAI", :routing_key => header.reply_to, :message_id => header.message_id) {}
+              end
+              call_pinger.call
+            end
+          end
+        end
+      end
+    end
+
+    it "should call the errback when there is a timeout" do
+      Fiber.wrap do
+        @pinger.start!
+        @pinger.should be_started
+
+        lambda { @pinger.ping!("exchangename", 0.01) }.should raise_error(WhoCan::TimeoutError)
+
+        done
+      end
+    end
+
+    it "should call the errback when there is an exception in queueing" do
+      exchange_name = 'exchangename'
+
+      Fiber.wrap do
+        @pinger.start!
+        @pinger.should be_started
+
+        flexmock(@pinger.channel).should_receive(:fanout).with(exchange_name).at_least.once.and_raise(TestingError)
+
+        lambda do
+          rval = @pinger.ping!(exchange_name, 0.1)
+
+          raise "Should not have returned #{rval.inspect}"
+
+        end.should raise_error(TestingError)
+        
+        done
+      end
+    end
+  end
+end
+

data/spec/who_can/synchrony/responder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module WhoCan
+  describe "Responder" do
+    include EventedSpec::AMQPSpec
+    include Logging
+    default_timeout 3.0
+    default_options :host => 'localhost'
+
+    amqp_before do
+      @who_can = WhoCan::Synchrony.new(AMQP.connection) #default opts
+      @exchange_name = "test_exchange"
+      @responder = @who_can.new_responder(@exchange_name)
+    end
+
+    it %[should respond to the pings] do
+      @responder.on_ping do |response|
+        response.delay = 0.1
+        response.response = "OHHAI"
+      end
+
+      Fiber.wrap do
+        @responder.setup!
+        logger.debug { "@responder.setup! returned" }
+        @responder.should be_started
+
+        AMQP::Channel.new do |channel|
+          channel.queue('', :exclusive => true, :auto_delete => true) do |queue|
+            queue.subscribe do |header, payload|
+              payload.should == "OHHAI"
+              done
+            end
+
+            channel.fanout(@exchange_name) do |exchange|
+              exchange.publish("PING", :reply_to => queue.name, :message_id => "MYMESSAGEID") {}
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/who_can.gemspec

@@ -13,16 +13,17 @@ Gem::Specification.new do |s|
   s.description = s.summary
 
   s.add_dependency('eventmachine',  '~> 1.0.0.beta.3')
+  s.add_dependency('em-synchrony',  '~> 1.0.0')
   s.add_dependency('amqp',          '~> 0.8.0.rc13')
   s.add_dependency('uuidtools',     '~> 2.1.2')
   s.add_dependency('deferred',      '~> 0.5.0')
   s.add_dependency('state_machine', '~> 1.0.1')
-  s.add_dependency('activesupport', '~> 3.0')
+  s.add_dependency('activesupport', '~> 3.0.7')
 
-  s.add_development_dependency('ZenTest', '>= 4.5.0')
-  s.add_development_dependency('rspec', '~> 2.5.0')
-  s.add_development_dependency('evented-spec', '~> 0.4.1')
-  s.add_development_dependency('flexmock', '~> 0.8.11')
+  s.add_development_dependency('ZenTest',       '>= 4.5.0')
+  s.add_development_dependency('rspec',         '~> 2.5.0')
+  s.add_development_dependency('evented-spec',  '~> 0.4.1')
+  s.add_development_dependency('flexmock',      '~> 0.8.11')
   s.add_development_dependency('ruby-graphviz', '~> 0.9.0')
 
   s.files         = `git ls-files`.split("\n")

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: who_can
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
+  hash: 62196449
+  prerelease: 6
   segments: 
   - 0
-  - 3
-  - 5
-  version: 0.3.5
+  - 4
+  - 0
+  - beta
+  - 1
+  version: 0.4.0.beta.1
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-21 00:00:00 Z
+date: 2012-01-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -37,9 +39,25 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: amqp
+  name: em-synchrony
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: amqp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -53,11 +71,11 @@ dependencies:
         - 13
         version: 0.8.0.rc13
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: uuidtools
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -69,11 +87,11 @@ dependencies:
         - 2
         version: 2.1.2
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: deferred
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -85,11 +103,11 @@ dependencies:
         - 0
         version: 0.5.0
   type: :runtime
-  version_requirements: *id004
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: state_machine
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -101,26 +119,27 @@ dependencies:
         - 1
         version: 1.0.1
   type: :runtime
-  version_requirements: *id005
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: activesupport
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 9
         segments: 
         - 3
         - 0
-        version: "3.0"
+        - 7
+        version: 3.0.7
   type: :runtime
-  version_requirements: *id006
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: ZenTest
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -132,11 +151,11 @@ dependencies:
         - 0
         version: 4.5.0
   type: :development
-  version_requirements: *id007
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -148,11 +167,11 @@ dependencies:
         - 0
         version: 2.5.0
   type: :development
-  version_requirements: *id008
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: evented-spec
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -164,11 +183,11 @@ dependencies:
         - 1
         version: 0.4.1
   type: :development
-  version_requirements: *id009
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   name: flexmock
   prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -180,11 +199,11 @@ dependencies:
         - 11
         version: 0.8.11
   type: :development
-  version_requirements: *id010
+  version_requirements: *id011
 - !ruby/object:Gem::Dependency 
   name: ruby-graphviz
   prerelease: false
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -196,7 +215,7 @@ dependencies:
         - 0
         version: 0.9.0
   type: :development
-  version_requirements: *id011
+  version_requirements: *id012
 description: An AMQP-based scatter-gather job queuing protocol library
 email: 
 - simms@hp.com
@@ -223,12 +242,18 @@ files:
 - lib/who_can/logging.rb
 - lib/who_can/pinger.rb
 - lib/who_can/responder.rb
+- lib/who_can/synchrony.rb
+- lib/who_can/synchrony/base.rb
+- lib/who_can/synchrony/connection_manager.rb
+- lib/who_can/synchrony/pinger.rb
+- lib/who_can/synchrony/responder.rb
 - lib/who_can/version.rb
 - poc/heartbeater.rb
 - poc/submitter.rb
 - poc/who_can_with_hearbeat.rb
 - scripts/cross_cluster_ping.rb
 - spec/spec_helper.rb
+- spec/support/em_synchrony_spec.rb
 - spec/support/evented_spec_extensions.rb
 - spec/support/logging.rb
 - spec/support/logging_progress_bar_formatter.rb
@@ -240,6 +265,10 @@ files:
 - spec/who_can/pinger_responder_integration_spec.rb
 - spec/who_can/pinger_spec.rb
 - spec/who_can/responder_spec.rb
+- spec/who_can/synchrony/base_spec.rb
+- spec/who_can/synchrony/connection_manager_spec.rb
+- spec/who_can/synchrony/pinger_spec.rb
+- spec/who_can/synchrony/responder_spec.rb
 - who_can.gemspec
 homepage: 
 licenses: []
@@ -261,12 +290,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -276,6 +307,7 @@ specification_version: 3
 summary: An AMQP-based scatter-gather job queuing protocol library
 test_files: 
 - spec/spec_helper.rb
+- spec/support/em_synchrony_spec.rb
 - spec/support/evented_spec_extensions.rb
 - spec/support/logging.rb
 - spec/support/logging_progress_bar_formatter.rb
@@ -287,3 +319,7 @@ test_files:
 - spec/who_can/pinger_responder_integration_spec.rb
 - spec/who_can/pinger_spec.rb
 - spec/who_can/responder_spec.rb
+- spec/who_can/synchrony/base_spec.rb
+- spec/who_can/synchrony/connection_manager_spec.rb
+- spec/who_can/synchrony/pinger_spec.rb
+- spec/who_can/synchrony/responder_spec.rb