who_can 0.3.4

data/lib/who_can/version.rb

@@ -0,0 +1,3 @@
+module WhoCan
+  VERSION = "0.3.4"
+end

data/poc/heartbeater.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/who_can', __FILE__)
+
+WhoCan.logger = logger = Logger.new($stderr).tap { |l| l.level = Logger::DEBUG }
+
+
+
+AMQP.start(:host => 'localhost') do |connection|
+#  connection.on_closed do
+#    logger.debug { "closed fired" }
+#  end
+#
+#  connection.on_tcp_connection_failure do
+#    logger.debug { "tcp connection failure fired" }
+#  end
+
+  connection.on_tcp_connection_loss do
+    logger.debug { "tcp connection loss fired" }
+  end
+
+  hb = WhoCan::Heartbeater::EKG.new(connection, :interval => 1.0)
+
+  hb.on_start do
+    logger.debug { "heartbeater started" }
+  end
+
+  hb.on_heartbeat_failure do
+    logger.debug { "Heartbeat failed! now we WOULD exit!!" }
+    EM.next_tick { EM.stop_event_loop }
+  end
+
+  hb.start!
+
+end
+
+

data/poc/submitter.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__)).uniq!
+
+require 'who_can'
+require 'logger'
+require 'ruby-debug'
+
+$log = Logger.new($stderr).tap { |log| log.level = Logger::DEBUG }
+
+PING_EXCHANGE = 'who_can.worker.ping.fanout'
+
+class Base
+  attr_reader :cnx 
+
+  def initialize(cnx)
+    @cnx = cnx
+  end
+
+  def channel
+    @channel ||= AMQP::Channel.new(cnx, AMQP::Channel.next_channel_id) #, :prefetch => 1)
+  end
+  alias :ch :channel
+
+  def ping_exchange
+    @ping_exchange ||= channel.fanout(PING_EXCHANGE, :durable => true)
+  end
+
+  def reply_exchange
+    @reply_exchange ||= channel.default_exchange
+  end
+end
+
+class Worker < Base
+  def setup
+    ch.once_opened do
+      $log.debug "channel opened"
+
+      ch.queue('', :exclusive => true) do |q|
+        q.bind(ping_exchange).subscribe do |header,payload|
+          v = rand() * 0.1
+
+          $log.debug "#1 Got #{header.message_id}, replying after #{v} delay"
+
+          EM.add_timer(v) do
+            reply_exchange.publish("worker_1 #{v}", :routing_key => header.reply_to, :message_id => header.message_id)
+          end
+        end
+      end
+
+      ch.queue('', :exclusive => true) do |q|
+        q.bind(ping_exchange).subscribe do |header,payload|
+          v = rand() * 0.1
+
+          $log.debug "#2 Got #{header.message_id}, replying after #{v} delay"
+
+          EM.add_timer(v) do
+            reply_exchange.publish("worker_2: #{v}", :routing_key => header.reply_to, :message_id => header.message_id)
+          end
+        end
+      end
+
+      ch.queue('', :exclusive => true) do |q|
+        q.bind(ping_exchange).subscribe do |header,payload|
+          v = rand() * 0.1
+
+          $log.debug "#3 Got #{header.message_id}, replying after #{v} delay"
+
+          EM.add_timer(v) do
+            reply_exchange.publish("worker_3: #{v}", :routing_key => header.reply_to, :message_id => header.message_id)
+          end
+        end
+      end
+
+      $log.debug "queues set up"
+    end
+  end
+end
+
+class Submitter < Base
+  attr_reader :requests, :pinger
+
+  def initialize(cnx, opts={})
+    super(cnx)
+    @pinger = WhoCan::Pinger.new(cnx)
+  end
+
+#   def ping!(run_id, &callback)
+#     $log.debug "ping! run_id #{run_id}"
+
+#     got_message = false
+
+#     ch.once_opened do
+#       ch.queue('', :exclusive => true, :auto_delete => true) do |q|
+
+#         # q here is a single-use queue for gathering repsonses to this ping
+#         q.subscribe do |header, payload|
+#           if got_message
+#             $log.debug "discarding response for messgae: #{header.message_id}"
+#           else
+#             $log.debug "unsubscribing queue: #{q.name}"
+#             q.unsubscribe
+
+#             got_message = true
+
+#             msg_id = header.message_id
+
+#             $log.debug "got a reply for #{msg_id}"
+#             callback.call(run_id, payload)
+#           end
+#         end
+
+#         msg_id = %Q[__message_#{run_id}_#{UUIDTools::UUID.random_create.to_s.tr('-', '')}__]
+#         requests[msg_id] = []
+
+#         ping_exchange.publish('PING', :reply_to => q.name, :message_id => msg_id) { }
+#         $log.debug "sent PING request on run #{run_id} msg_id: #{msg_id}"
+#       end
+#     end
+#   end
+
+  def ping!(run_id, &callback)
+    @pinger.ping!(PING_EXCHANGE) do |header,payload|
+      $log.debug { "received message for run_id: #{run_id}, payload: #{payload}" }
+      callback.call(run_id, payload)
+    end
+  end
+
+  def self.main(cnx)
+    sub = new(cnx)
+
+    callback = lambda do |run_id, requests|
+      $log.debug "results of run_id #{run_id}: #{requests.inspect}"
+
+      if run_id >= 100
+        $log.debug "Did 100 rounds, exiting"
+        cnx.close { EM.stop { exit } }
+      else
+        next_id = run_id + 1
+        $log.debug "scheduling run ##{next_id}"
+        EM.next_tick { sub.ping!(next_id, &callback) }
+      end
+    end
+
+    $stderr.puts "calling ping with run_id 0"
+    sub.ping!(0, &callback)
+  end
+end
+
+def main
+  EventMachine.run do
+    AMQP.connect(AMQP::Client.parse_connection_uri("amqp://localhost")) do |cnx|
+      shutdown = lambda do
+        $log.debug "shutting down"
+        cnx.close do
+          EM.stop { exit }
+        end
+      end
+
+      trap "INT", shutdown
+
+      case ARGV.first
+      when 'submitter'
+        Submitter.main(cnx)
+      when 'worker'
+        Worker.new(cnx).setup
+      else
+        $stderr.puts "what?!"
+        shutdown
+      end
+      
+    end
+  end
+end
+
+$stderr.sync = true
+
+main if __FILE__ == $0
+
+

data/poc/who_can_with_hearbeat.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../../lib/who_can', __FILE__)
+
+WhoCan.logger = logger = Logger.new($stderr).tap { |l| l.level = Logger::DEBUG }
+
+
+
+AMQP.start(:host => 'localhost') do |connection|
+
+  who_can = WhoCan.new(connection)
+  who_can.on_disconnection do
+    $stderr.puts("got a valid disconnection")
+  end
+
+  who_can.start_monitoring!
+
+end
+
+

data/scripts/cross_cluster_ping.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'who_can'
+require 'logger'
+
+WhoCan.logger = Logger.new($stderr).tap { |n| n.level = Logger::DEBUG }
+
+class CrossClusterPinger
+  include WhoCan::Logging
+  include Deferred::Accessors
+
+  CLUSTER_NODE_ONE = 'amqp://localhost:15672'
+  CLUSTER_NODE_TWO = 'amqp://localhost:15673'
+
+  EXCHANGE_NAME = 'who_can.cluster.pinger.test'
+
+  deferred_event :pinger_started, :stop
+
+  def initialize
+    @trapped_signal = false
+  end
+
+  def ping_on_schedule
+    @ping_timer ||= EM.add_periodic_timer(1.0) do
+      @pinger.ping!(EXCHANGE_NAME) do |header,payload|
+        logger.debug { "got message_id: #{header.message_id}, payload: #{payload}" }
+      end.errback do |e|
+        logger.error { "got exception #{e.to_std_error}" }
+      end
+    end
+  end
+
+  def start_pinger(&blk)
+    on_pinger_started(&blk)
+
+    @wc_pinger = WhoCan.new(CLUSTER_NODE_ONE).tap do |wc|
+      wc.on_open do
+        @pinger = WhoCan::Pinger.new(wc.connection)
+
+        @pinger.start! do
+          logger.debug { "pinger started, scheduling perioding ping" }
+          on_pinger_started.succeed
+          ping_on_schedule
+        end
+      end
+    end
+  end
+
+  def start_responder(&blk)
+    @wc_responder = WhoCan.new(CLUSTER_NODE_TWO).tap do |wc|
+      wc.on_open do
+        @responder = WhoCan::Responder.new(wc.connection, EXCHANGE_NAME)
+
+        @responder.on_ping do |rsp|
+          logger.debug {  "responder got ping id: #{rsp.header.message_id} payload: #{rsp.payload}" }
+          rsp.delay = 0.1
+          rsp.response = "Time now: #{Time.now.to_s}"
+        end
+
+        @responder.setup!(&blk)
+      end
+    end
+  end
+
+  def stop!(&blk)
+    on_stop(&blk)
+
+    @ping_timer.cancel
+
+    @responder.close! do
+      @wc_responder.close! do
+        @wc_pinger.close! do
+          on_stop.succeed
+        end
+      end
+    end
+
+    on_stop
+  end
+
+  def main
+    EM.run do
+      start_pinger do
+        start_responder do
+          logger.debug { "running" }
+        end
+      end
+
+      trap('INT') do
+        if @trapped_signal
+          $stderr.puts "EXITING IMMEDIATELY!!"
+          EM.stop_event_loop 
+        else
+          @trapped_signal = true
+          stop! do
+            EM.next_tick { EM.stop_event_loop }
+          end
+        end
+      end
+    end
+  end
+end
+
+CrossClusterPinger.new.main if __FILE__ == $0

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'rspec'
+require 'who_can'
+require 'evented-spec'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__), "support/**/*.rb"))].each {|f| require f}
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :flexmock
+
+  config.include(FlexMock::ArgumentTypes)
+end
+

data/spec/support/evented_spec_extensions.rb

@@ -0,0 +1,14 @@
+# module EventedSpec
+#   module SpecHelper
+#     module AMQP
+#       module ExampleMethods
+#         def with_open_channel(opts={})
+#           AMQP::Channel.new(opts) do |chan,_|
+#             yield chan
+#           end
+#         end
+#       end
+#     end
+#   end
+# end
+

data/spec/support/logging.rb

@@ -0,0 +1,8 @@
+log_path = File.expand_path('../../../test.log', __FILE__)
+
+WhoCan.logger = Logger.new(log_path).tap { |l| l.level = Logger::DEBUG }
+
+# def logger
+#   WhoCan.logger
+# end
+

data/spec/support/logging_progress_bar_formatter.rb

@@ -0,0 +1,14 @@
+require 'rspec/core/formatters/progress_formatter'
+
+module Motionbox
+  # essentially a monkey-patch to the ProgressBarFormatter, outputs 
+  # '== #{example_proxy.description} ==' in the logs before each test.  makes it
+  # easier to match up tests with the SQL they produce
+  class LoggingProgressBarFormatter < RSpec::Core::Formatters::ProgressFormatter
+    def example_started(example)
+      WhoCan.logger.info(yellow("\n=====<([ #{example.full_description} ])>=====\n"))
+      super
+    end
+  end
+end
+

data/spec/who_can/base_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+
+module WhoCan
+
+  describe "Base" do
+    describe "using an existing connection" do
+      include EventedSpec::AMQPSpec
+      default_timeout 3.0
+      default_options :host => 'localhost'
+
+      amqp_before do
+        @who_can = WhoCan.new(AMQP.connection)
+      end
+
+      it "should fire the on_disconnection when a tcp failure occurs" do
+        @who_can.start_monitoring!
+        @who_can.on_disconnection do
+          true.should be_true #this should be much better
+          done
+        end
+        @who_can.on_open do
+          AMQP.connection.tcp_connection_lost
+        end
+      end
+
+      it "should fire disconnection on close!" do
+        @who_can.on_disconnection do
+          true.should be_true #this should be much better
+          done
+        end
+        @who_can.on_open do
+          @who_can.close!
+        end
+      end
+
+      it "should fire disconnection on heartbeat_failure" do
+        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(true)
+        end
+
+        flexmock(Heartbeater::EKG).should_receive(:new).and_return(fake_ekg)
+        @who_can.start_monitoring!
+
+        @who_can.on_disconnection do
+          true.should be_true #this should be much better
+          done
+        end
+        @who_can.on_open do
+          heartbeat_failure_block.should_not be_nil
+          heartbeat_failure_block.call
+        end
+      end
+
+
+    end
+
+
+
+  end
+
+end