iron_mq 4.0.3 → 4.0.5

data/lib/iron_mq/response.rb

@@ -2,22 +2,39 @@ require 'ostruct'
 
 module IronMQ
 
-  class ResponseBase < OpenStruct
+
+  class ResponseBase
+    attr_reader :raw, :code
+
     def initialize(data, code = 200)
-      super(data.merge(:code => code.to_i))
+      @raw = data
+      @code = code
+      #super(data.merge(:code => code.to_i))
     end
 
-    def [](key)
-      send(key.to_s)
+    def id
+      @raw["id"]
     end
 
-    def raw
-      res = stringify_keys(marshal_dump)
-      # `code` is not part of response body
-      res.delete("code")
+    def [](key)
+      @raw[key]
+    end
 
-      res
+    def msg
+      @raw["msg"]
     end
+    #
+    #def raw
+    #  if @raw.nil?
+    #    @raw = call_api_and_parse_response(:get, "", {}, false)
+    #  end
+    #  #res = stringify_keys(marshal_dump)
+    #  ## `code` is not part of response body
+    #  #res.delete("code")
+    #  #
+    #  #res
+    #  @raw
+    #end
 
     private
 

data/lib/iron_mq/subscribers.rb

@@ -17,7 +17,7 @@ module IronMQ
       if ex.code == 404
         Rest.logger.info("Delete got 404, safe to ignore.")
         # return ResponseBase as normal
-        ResponseBase.new({"msg" => "Deleted"})
+        ResponseBase.new({"msg" => "Deleted"}, 404)
       else
         raise ex
       end

data/lib/iron_mq/version.rb

@@ -1,4 +1,3 @@
 module IronMQ
-  VERSION = "4.0.3"
+  VERSION = "4.0.5"
 end
-

data/test/quick_run.rb

@@ -1,7 +1,8 @@
 require 'quicky'
+require 'go'
 require File.expand_path('test_base.rb', File.dirname(__FILE__))
 
-TIMES = 10
+TIMES_PER_THREAD = 10
 
 class QuickRun < TestBase
 
@@ -10,22 +11,21 @@ class QuickRun < TestBase
   end
 
   def test_quick
-    queue_name = 'ironmq-gem_quick'
+
+    queue_name = "ironmq_gem_quick_#{rand(100)}"
     clear_queue(queue_name)
     queue = @client.queue(queue_name)
 
     quicky = Quicky::Timer.new
-
-    # make connection
-    res2 = queue.get
-    # p res2
-
-    quicky.loop(:test_quick, TIMES, :warmup => 2) do |i|
-      puts "==== LOOP #{i} =================================="
-
+    j = 0
+    quicky.loop(:test_quick, TIMES_PER_THREAD) do |i|
+      puts "==== LOOP #{i || j} =================================="
+      j += 1
+      body = "hello world!"
       post_id = nil
-      quicky.time(:post, :warmup => 2) do
-        res = queue.post("hello world!")
+      quicky.time(:post) do
+        puts "post"
+        res = queue.post(body)
         # p res
         assert_not_nil res
         assert_not_nil res.id
@@ -33,16 +33,17 @@ class QuickRun < TestBase
         assert !(res.msg.nil? || res.msg.empty?)
       end
 
-      quicky.time(:get, :warmup => 2) do
+      quicky.time(:get) do
+        puts "get"
         msg = queue.get
-        # p res
-        puts "post_id=" + post_id.inspect
         assert_not_nil msg.id
         assert_equal msg.id, post_id
         assert !(msg.body.nil? || msg.body.empty?)
+        assert_equal body, msg.body
       end
 
-      quicky.time(:delete, :warmup => 2) do
+      quicky.time(:delete) do
+        puts "delete"
         res = queue.delete(post_id)
         # p res
         assert_not_nil res
@@ -51,38 +52,20 @@ class QuickRun < TestBase
 
       msg = queue.get
       # p msg
-      assert_nil res
-
+      assert_nil msg
 
-      q = @client.queue('test2')
-      res = q.post("hello world!")
-      # p res
-      assert_not_nil res.id
-      assert_not_nil res.msg
-
-      msg = q.get
-      # p res
-      assert_not_nil msg
-      assert_not_nil msg.id
-      assert_not_nil msg.body
-
-      res = msg.delete
-      # p res
-      assert_equal 200, res.code, "API must delete message and response with HTTP 200 status, but returned HTTP #{res.code}"
     end
     puts "count: #{quicky.results(:post).count}"
     puts "avg post: #{quicky.results(:post).duration}"
     puts "avg get: #{quicky.results(:get).duration}"
     puts "avg delete: #{quicky.results(:delete).duration}"
-
-    # delete queue on test complete
+    puts "queue size: #{queue.reload.size}"
+    assert_equal 0, queue.size
     resp = queue.delete_queue
-    assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
+    assert_equal 200, resp.code, "API must respond with HTTP 200 status, but returned HTTP #{resp.code}"
 
-    resp = @client.queue('test2').delete_queue
-    assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
-  end
 
+  end
 
 end
 

data/test/quick_run2.rb

@@ -0,0 +1,114 @@
+require 'quicky'
+require 'go'
+require 'pp'
+require File.expand_path('test_base.rb', File.dirname(__FILE__))
+
+THREADS = 10
+TIMES_PER_THREAD = 1000
+
+class QuickRun < TestBase
+
+  def setup
+    super
+  end
+
+  def test_quick
+    Go.logger.level = Logger::DEBUG
+    Concur.logger.level = Logger::DEBUG
+    ch = Go::Channel.new
+    results = nil
+
+    (THREADS-1).times do |ti|
+
+        go do
+          do_it(ch, ti)
+        end
+
+      end
+
+    ch.each do |r|
+      puts "results: #{r.inspect}"
+      if results
+        results.merge!(r)
+      else
+        results = r
+      end
+    end
+    pp results.to_hash
+
+  end
+
+  def do_it(ch, ti)
+
+    begin
+
+      queue_name = "ironmq_gem_quick_#{ti}_#{rand(1000)}"
+      clear_queue(queue_name)
+      queue = @client.queue(queue_name)
+
+      quicky = Quicky::Timer.new
+      consumer_ch = Go::Channel.new
+      quicky.loop(:test_quick, TIMES_PER_THREAD) do |i|
+        puts "==== LOOP t#{ti} - #{i} =================================="
+
+        if i == 50 || i == TIMES_PER_THREAD-1
+          start_consumer(quicky, queue, consumer_ch)
+        end
+
+        post_id = nil
+        quicky.time(:post) do
+          res = queue.post("hello world!")
+          # p res
+          assert_not_nil res
+          assert_not_nil res.id
+          post_id = res.id
+          assert !(res.msg.nil? || res.msg.empty?)
+        end
+
+      end
+      # wait for consumer to end
+      #i = 0
+      #consumer_ch.each do |r|
+      #  i+=1
+      #  puts "consumer #{r}"
+      #  consumer_ch.close if i == TIMES_PER_THREAD
+      #end
+      sleep TIMES_PER_THREAD / 2
+
+      puts "count: #{quicky.results(:post).count}"
+      puts "avg post: #{quicky.results(:post).duration}"
+      puts "avg get: #{quicky.results(:get).duration}"
+      puts "avg delete: #{quicky.results(:delete).duration}"
+      puts "queue size: #{queue.reload.size}"
+      resp = queue.delete_queue
+      assert_equal 200, resp.code, "API must respond with HTTP 200 status, but returned HTTP #{resp.code}"
+
+      ch << quicky.results
+
+    rescue Exception => ex
+      p ex
+      p ex.backtrace
+    end
+
+  end
+
+  def start_consumer(quicky, queue, channel)
+    go do
+      while true do
+        msg = nil
+        quicky.time(:get) do
+          msg = queue.get
+        end
+        if msg.nil?
+          channel << "done"
+          break
+        end
+        quicky.time(:delete) do
+          msg.delete
+        end
+      end
+    end
+  end
+
+end
+

data/test/test_alerts.rb

@@ -0,0 +1,142 @@
+# Put config.yml file in ~/Dropbox/configs/ironmq_gem/test/config.yml
+require File.expand_path('test_base.rb', File.dirname(__FILE__))
+require 'logger'
+
+class TestAlerts < TestBase
+
+  def setup
+    super
+    @skip = @host.include? 'rackspace'
+    return if @skip # bypass these tests if rackspace
+  end
+
+  def test_size_alerts
+    return if @skip
+
+    # Add a normal size alert
+    # Post x messages
+    # check to ensure alert was triggered
+
+    x = rand(1000)
+    qname = "alert-queue-#{x}"
+    clear_queue(qname)
+    queue = @client.queue(qname)
+    puts "queue: #{queue}"
+    trigger_value = 10
+    # todo: should :queue be called something else, like target_queue? or url and have to use ironmq:// url?
+    target_queue_name = "alert-target-queue-#{x}"
+    r = queue.add_alert({:type => "size", :trigger => trigger_value, :queue => target_queue_name})
+    p r
+
+    alerts = queue.alerts
+    p alerts
+    assert_equal 1, alerts.size
+    alert = alerts[0]
+    assert_equal "size", alert.type
+    assert_equal trigger_value, alert.trigger
+    assert_equal target_queue_name, alert.queue
+
+    target_queue = @client.queue(target_queue_name)
+    assert_equal 0, target_queue.size
+
+    (trigger_value - 1).times do |i|
+      puts "posting #{i}"
+      queue.post("message #{i}")
+    end
+    sleep 0.5
+    assert_equal 0, target_queue.size
+    queue.post("message #{trigger_value}")
+    sleep 0.5
+    assert_equal trigger_value, queue.size
+    assert_equal 1, target_queue.size
+
+    # now let's get it down the reset point and trigger it again
+    (trigger_value / 2).times do |i|
+      m = queue.get
+      m.delete
+    end
+    assert_equal trigger_value/2, queue.size
+    assert_equal 1, target_queue.size
+
+    # once it's at half, it should reset so let's get it back up to trigger_value again
+    (trigger_value / 2).times do |i|
+      queue.post("second set: message #{i}")
+    end
+    sleep 0.5
+    assert_equal trigger_value, queue.size
+    assert_equal 2, target_queue.size
+
+    queue.delete_queue
+    target_queue.delete_queue
+
+  end
+
+
+  def test_progressive_alerts
+    return if @skip
+
+    # Add a normal size alert
+    # Post x messages
+    # check to ensure alert was triggered
+
+    x = rand(1000)
+    qname = "alert-queue-#{x}"
+    queue = @client.queue(qname)
+    trigger_value = 10
+    # todo: should :queue be called something else, like target_queue? or url and have to use ironmq:// url?
+    target_queue_name = "alert-target-queue-#{x}"
+    r = queue.add_alert({:type => "progressive", :trigger => trigger_value, :queue => target_queue_name})
+    p r
+
+    alerts = queue.alerts
+    assert_equal 1, alerts.size
+    alert = alerts[0]
+    assert_equal "progressive", alert.type
+    assert_equal trigger_value, alert.trigger
+    assert_equal target_queue_name, alert.queue
+
+    target_queue = @client.queue(target_queue_name)
+    assert_equal 0, target_queue.size
+
+    post_messages(queue, trigger_value)
+    assert_equal trigger_value, queue.size
+    assert_equal 1, target_queue.size
+
+    # now let's do it again and see if it tiggers again
+    post_messages(queue, trigger_value)
+    assert_equal trigger_value * 2, queue.size
+    assert_equal 2, target_queue.size
+
+    # now let's do it once again and see if it triggers again
+    post_messages(queue, trigger_value)
+    assert_equal trigger_value * 3, queue.size
+    assert_equal 3, target_queue.size
+
+    # now let's get it down to the reset point and trigger it again
+    (trigger_value).times do |i|
+      m = queue.get
+      m.delete
+    end
+    sleep 0.5
+    assert_equal trigger_value*2, queue.size
+    assert_equal 3, target_queue.size
+
+    # once it's at half, it should reset so let's get it back up to trigger_value again
+    post_messages(queue, trigger_value)
+    assert_equal trigger_value*3, queue.size
+    assert_equal 4, target_queue.size
+
+    queue.delete_queue
+    target_queue.delete_queue
+
+  end
+
+  def post_messages(queue, num)
+    (num).times do |i|
+      queue.post("message #{i}")
+    end
+    sleep 0.5
+  end
+  
+
+end

data/test/test_base.rb

@@ -3,13 +3,6 @@ require 'test/unit'
 require 'yaml'
 require 'uber_config'
 
-unless Hash.instance_methods.include?(:default_proc=)
-  class Hash
-    def default_proc=(proc)
-    end
-  end
-end
-
 begin
   require File.expand_path('../lib/iron_mq', File.dirname(__FILE__))
 rescue Exception => ex
@@ -18,7 +11,8 @@ rescue Exception => ex
 end
 
 LOG = Logger.new(STDOUT)
-MAX_TRIES = 100
+LOG.level = Logger::INFO
+MAX_TRIES = 10
 
 class TestBase < Test::Unit::TestCase
 
@@ -44,11 +38,19 @@ class TestBase < Test::Unit::TestCase
     queue_name ||= @queue_name
 
     queue = @client.queue(queue_name)
-    queue.post("test")
 
     puts "clearing queue #{queue_name}"
-    queue.clear
-    puts 'cleared.'
+    begin
+      queue.clear
+      puts 'cleared.'
+    rescue Rest::HttpError => ex
+      if ex.code == 404
+        # this is fine
+      else
+        raise ex
+      end
+    end
+
   end
 
   def assert_performance(time)