who_can 0.3.4

data/lib/who_can/heartbeater.rb

@@ -0,0 +1,7 @@
+module WhoCan
+  module Heartbeater
+  end
+end
+
+require 'who_can/heartbeater/beat'
+require 'who_can/heartbeater/ekg'

data/lib/who_can/heartbeater/beat.rb

@@ -0,0 +1,72 @@
+module WhoCan
+  module Heartbeater
+    class Beat
+      include Logging
+      include Deferred
+
+      # mainly used for hooking-in tests
+      deferred_event :after_publish, :prefix => false
+
+      attr_reader :channel, :queue, :beat_id, :timeout_after
+
+      # @param [AMQP::Channel] channel the amqp channel we are to use
+      #
+      # @param [String] beat_id a unique identifier for this beat instance
+      #
+      # @param [Numeric] timeout how long do we wait until we decide this beat
+      #   was a failure. if nil, no timeout will be set. Timeout is started
+      #   before we open the channel, and is cancelled on successful return
+      #   message
+      #
+      def initialize(channel, queue, beat_id, timeout=nil)
+        @channel = channel
+        @queue   = queue
+        @beat_id = beat_id
+        @timeout_after = timeout
+        @started = false
+      end
+
+      def pending?
+        @deferred_status.nil? or (@deferred_status == :unknown)
+      end
+
+      def fired?
+        !pending?
+      end
+
+      def cancel!
+        return if fired?
+
+        logger.info { "#{beat_id} cancel called!" }
+
+        cancel_timeout
+        @cancelled = true
+        succeed
+      end
+
+      def cancelled?
+        @cancelled
+      end
+
+      def ping_received!
+        succeed if pending? and not cancelled?
+      end
+
+      def start!
+        return if @started
+        @started = true
+
+        timeout(timeout_after) if timeout_after
+
+        channel.once_opened do
+          errback_on_exception do
+            channel.default_exchange.publish('BEAT', :routing_key => queue.name, :message_id => beat_id) do
+              logger.debug { "message #{beat_id} sent" }
+              after_publish.succeed
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/who_can/heartbeater/ekg.rb

@@ -0,0 +1,169 @@
+module WhoCan
+  module Heartbeater
+    # Pings the broker at regular intervals. After N number of successive
+    # failures, will fire the on_heartbeat_failure callback (note: not the
+    # errback, the *callback*). Due to the nature of Deferreds, after a failure
+    # a Monitor instance must be discarded.
+    #
+    # a successful beat resets failure_count
+    #
+    class EKG
+      include Logging
+      include Deferred
+
+      attr_reader :connection, :queue, :interval, :max_failures, :failure_count
+
+      # fired when the amqp channel has opened and we've started sending beats
+      deferred_event :start
+
+      # fired when failure_count >= max_failures
+      deferred_event :heartbeat_failure
+
+      deferred_event :shutdown
+
+
+      # Create a new Monitor.
+      #
+      # @option opts [Integer] :max_failures (3) fire the on_heartbeat_failure
+      #   callback after this many failures
+      #
+      # @option opts [Numeric] :interval (2.0) interval between beats
+      #
+      # @option opts [Numeric] :timeout (5.0) time to live for a single beat
+      def initialize(connection, opts={})
+        opts = {:interval => 2.0, :max_failures => 3, :timeout => 5.0}.merge(opts)
+
+        @connection     = connection
+        @channel        = nil
+        @timer          = nil
+        @interval       = opts[:interval]
+        @max_failures   = opts[:max_failures]
+        @beat_timeout_after = opts[:timeout]
+        @queue          = nil
+        @failure_count  = 0
+        @running        = false
+        @beat_num       = 0
+        @outstanding_beats = {}
+      end
+
+      def channel
+        @channel ||= AMQP::Channel.new(connection)
+      end
+
+      def start!(&blk)
+        on_start(&blk)
+        return on_start if @running
+        @running = true
+
+        connection.on_tcp_connection_loss do 
+          logger.error { "on_tcp_connection_loss callback fired!!" }
+          heartbeat_failure!
+        end
+
+        connection.on_open do
+          channel.once_opened do
+            channel.on_error { |*a| logger.error { "channel.on_error called with #{a.inspect}" } }
+            channel.queue('', :exclusive => true, :auto_delete => true) do |q|
+              @queue = q
+
+              confirmed = lambda do |*|
+                logger.debug { "confirmed queue subscription!" }
+                on_start.succeed
+                do_beat!
+              end
+
+              @queue.subscribe(:confirm => confirmed, &method(:handle_message))
+            end
+          end
+        end
+        on_start
+      end
+
+      def shutdown!(&blk)
+        on_shutdown(&blk)
+        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" }
+          on_shutdown.succeed
+        end
+
+        @channel.close {
+          close_failsafe_timer.cancel
+          logger.debug { "channel has closed!" }
+          on_shutdown.succeed 
+        }
+
+        on_shutdown
+      rescue AMQ::Client::ConnectionClosedError
+        on_shutdown.succeed
+      end
+
+      def handle_message(header, payload)
+        msg_id = header.message_id
+
+        if outstanding_beat = @outstanding_beats.delete(msg_id)
+          outstanding_beat.ping_received!
+        end
+      end
+
+      def do_beat!
+        return unless @running
+        @timer = nil
+
+        beat_id = "beat_#{@beat_num}"
+        @beat_num += 1
+
+        beat = Beat.new(channel, queue, beat_id, @beat_timeout_after)
+
+        @outstanding_beats[beat_id] = beat
+
+        beat.ensure_that { @outstanding_beats.delete(beat_id) }
+
+        beat.callback do
+          logger.debug { "beat #{beat_id.inspect} was successful" }
+          @failure_count = 0
+        end
+
+        beat.errback do |*a|
+          handle_failure(beat, *a)
+        end
+
+        beat.start!
+
+        # set this up to happen regularly if it hasn't been done already
+        @timer = EM::Timer.new(interval) { do_beat! }
+      end
+
+      def heartbeat_failure!
+        logger.warn { "heartbeat_failure!" }
+        cancel_outstanding_beats!
+        on_heartbeat_failure.succeed
+        shutdown!
+      end
+
+      def handle_failure(beat, exception=nil)
+        logger.warn { "beat errback called! #{beat.beat_id}" }
+        @failure_count += 1
+        if @failure_count >= @max_failures
+          logger.warn { "@failure_count #{@failure_count} >= @max_failures #{@max_failures}, firing heartbeat_failure" }
+          heartbeat_failure!
+        end
+      end
+
+      # @private
+      # goes through the outstanding_beats and cancels them
+      def cancel_outstanding_beats!
+        outstanding_beats, @outstanding_beats = @outstanding_beats, {}
+        outstanding_beats.values.each { |b| b.cancel! }
+      end
+    end
+  end
+end

data/lib/who_can/logging.rb

@@ -0,0 +1,12 @@
+module WhoCan
+  module Logging
+    def self.included(base)
+      base.extend(Logging)
+    end
+
+    def logger
+      WhoCan.logger
+    end
+  end
+end
+

data/lib/who_can/pinger.rb

@@ -0,0 +1,82 @@
+module WhoCan
+  class Pinger
+    include Deferred::Accessors
+    include Logging
+    
+    deferred_event :start
+
+    attr_reader :connection, :channel
+
+    def self.create_msg_id
+      "who_can_#{UUIDTools::UUID.random_create.to_s.tr('-', '_')}"
+    end
+
+    def initialize(connection)
+      @connection = connection
+      @needs_reply = {}
+      @queue = nil
+    end
+
+   
+    def start!(&blk)
+      EM.schedule do
+        AMQP::Channel.new(connection) do |channel,_|
+          @channel = channel
+          logger.debug { "pinger channel is now open" }
+
+          channel.on_error do |*a|
+            logger.error { "channel on_error called with: #{a.inspect}" }
+          end
+
+          channel.queue('', :exclusive => true, :auto_delete => true) do |q|
+            logger.debug { "queue opened: #{q.name} exclusive, auto_delete" }
+
+            @queue = q
+            block_callback = lambda do |*args|
+              logger.debug {"calling back to with_queue"}
+              on_start.succeed
+            end
+
+            logger.debug {"subscribing to the response queue"}
+            @queue.subscribe(:confirm => block_callback, &method(:handle_response))
+          end
+        end
+      end
+      on_start(&blk)
+    end
+  
+    # returns immediately, will call the given callback with the headers and
+    # payload of the "winning" message (the first ping back from the workers we
+    # receive).
+    def ping!(exchange, timeout=5, &callback)
+      logger.debug { "sending a ping to #{exchange}" }
+      deferred = Deferred::Default.new
+      deferred.callback(&callback)
+      deferred.timeout(timeout)
+      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
+      deferred
+    rescue Exception => e
+      logger.error {"received an exception on ping!: #{e.to_std_format}"}
+      deferred.fail(e)
+      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)
+        end
+      end
+    end
+  end
+end

data/lib/who_can/responder.rb

@@ -0,0 +1,129 @@
+module WhoCan
+  class Responder
+    include Deferred::Accessors
+    include Logging
+    
+    deferred_event :start
+
+    class Response
+      attr_reader :header, :payload, :delay, :response
+
+      attr_accessor :do_not_respond
+
+      def initialize(header, payload)
+        @header, @payload = header, payload
+        @response = ''
+        @do_not_respond = false
+      end
+      
+      def delay=(val)
+        if val.kind_of?(String) or not val.respond_to?(:to_f)
+          raise TypeError, "return value of on_ping callback should respond_to? :to_f, not be #{val.inspect}"
+        end
+
+        @delay = val.to_f
+      end
+
+      def response=(val)
+        @response = val.to_s
+      end
+
+      def validate!
+        raise DelayMustBeSetError unless delay
+      end
+    end
+
+    attr_reader :channel, :ping_exchange, :queue, :ping_exchange_name, :connection
+
+    # channel here is an honest-to-goodness AMQP::Channel, not a ChannelPool object
+    def initialize(connection, ping_exchange_name)
+      @connection = connection
+      @ping_exchange_name = ping_exchange_name
+      @on_ping_cb = nil
+      @set_up = false
+    end
+
+    # wc = WhoCan.new(connection_opts)
+    # responder = wc.new_responder(:retriever)
+    # responder.set_load(0.1)
+
+    # wc = WhoCan.new(connection_opts)
+    # wc.who_can?("retriever") { |payload| yay!}
+
+    # resp = wc.new_responder(ping_exch_name)
+    #
+    # resp.on_ping do |obj|
+    #   obj.header  # msg headers
+    #   obj.paylod  # msg payload
+    #
+    #   obj.delay    = load_avg * num_slots * Math::PI
+    #   obj.response = "something here"
+    # end
+    #
+    # wc = WhoCan.new(connection_opts)
+    # wc.on_ping("retriever") do |resp|
+    #
+    # end
+
+    def setup!(&blk)
+      return on_start if @set_up
+      @set_up = true
+      @close_requested = false
+      on_start(&blk)
+      AMQP::Channel.new(connection) do |channel,_|
+        @channel = channel
+        @ping_exchange = @channel.fanout(ping_exchange_name, :nowait => false)
+        @queue = @channel.queue('', :exclusive => true, :auto_delete => true)
+
+        unless @close_requested
+          @queue.bind(@ping_exchange) do
+            #logger.debug {"subscribing to the #{@ping_exchange_name}"}
+
+            confirm_queue = lambda do |*a|
+              #logger.debug { "queue subscribed to #{@ping_exchange_name}" }
+              on_start.succeed
+            end
+
+            @queue.subscribe(:confirm => confirm_queue, &method(:handle_message))
+          end #bind
+        end # unless
+      end
+      on_start
+    end
+
+    def handle_message(header, payload)
+      if @on_ping_cb
+        resp = Response.new(header, payload)
+        logger.debug {"ping request came in, sending off to get response"}
+        @on_ping_cb.call(resp)
+
+        if resp.do_not_respond
+          logger.debug { "do_not_respond flag set, not sending reply" }
+        else
+          resp.validate!
+          #logger.debug {"adding timer of: #{resp.delay} and then publishing message"}
+          EM.add_timer(resp.delay) do
+            logger.debug {"publishing ping response to #{header.reply_to} after delay of #{resp.delay} happened"}
+            channel.default_exchange.publish(resp.response, :routing_key => header.reply_to, :message_id => header.message_id)
+          end
+        end
+      end
+    end
+
+    def close!
+      return false if !@set_up or @close_requested
+      @close_requested = true
+
+      @queue.unsubscribe if @queue
+      @queue = nil
+      @set_up = false
+    end
+
+    # Register a callback that must return a Numeric (either float or integer)
+    # that will be used to delay the response to the pinger.
+    def on_ping(&block)
+      @on_ping_cb = block
+    end
+  end
+end
+