iron_mq 3.1.0 → 4.0.0

data/lib/iron_mq/queues.rb

@@ -2,210 +2,217 @@ require 'cgi'
 require 'iron_mq/subscribers'
 
 module IronMQ
-  class Queues
 
-    attr_accessor :client
+  class Queue < ResponseBase
+    attr_reader :name
 
-    def initialize(client)
+    def initialize(client, queue_name)
       @client = client
+      @name = queue_name
+      super({"name" => queue_name})
     end
 
-    def self.path(options)
-      path = "projects/#{options[:project_id]}/queues"
-      name = options[:name] || options[:queue_name] || options['queue_name']
-      if name
-        path << "/#{CGI::escape(name)}"
+    def info
+      info  = raw
+      begin
+        # Do not instantiate response
+        info = call_api_and_parse_response(:get, '', {}, false)
+      rescue Rest::HttpError
       end
-      path
-    end
 
-    def path(options={})
-      options[:project_id] = @client.project_id
-      Queues.path(options)
+      ResponseBase.new(info)
     end
 
-    def list(options={})
-      ret = []
-      r1 = @client.get("#{path(options)}", options)
-      #p r1
-      res = @client.parse_response(r1)
-      res.each do |q|
-        #p q
-        q = Queue.new(@client, q)
-        ret << q
-      end
-      ret
+    def size
+      info.size.to_i
     end
 
-    def clear(options={})
-      @client.logger.debug "Clearing queue #{options[:name]}"
-      r1 = @client.post("#{path(options)}/clear", options)
-      @client.logger.debug "Clear result: #{r1}"
-      r1
+    def total_messages
+      info.total_messages.to_i
     end
 
-    def delete(options={})
-      @client.logger.debug "Deleting queue #{options[:name]}"
-      r1 = @client.delete("#{path(options)}", options)
-      @client.logger.debug "Delete result: #{r1}"
-      r1
+    def new?
+      id.nil?
     end
 
-    # options:
-    #  :name => can specify an alternative queue name
-    def get(options={})
-      options[:name] ||= @client.queue_name
-      r = @client.get("#{path(options)}")
-      #puts "HEADERS"
-      #p r.headers
-      res = @client.parse_response(r)
-      return Queue.new(@client, res)
+    def push_queue?
+      # FIXME: `push_type` parameter in not guaranted it's push queue.
+      #        When the parameter absent it is not guaranted that queue is not push queue.
+      ptype = push_type
+      not (ptype.nil? || ptype.empty?)
     end
 
-    # Update a queue
-    # options:
-    #  :name => if not specified, will use global queue name
-    #  :subscribers => url's to subscribe to
-    #  :push_type => multicast (default) or unicast.
-    def post(options={})
-      options[:name] ||= @client.queue_name
-      res = @client.parse_response(@client.post(path(options), options))
-      #p res
-      res
+    def update(options)
+      call_api_and_parse_response(:post, "", options)
     end
 
+    alias_method :update_queue, :update
 
-  end
-
-  class Queue
-
-    attr_reader :client
-
-    def initialize(client, res)
-      @client = client
-      @data = res
+    def clear
+      call_api_and_parse_response(:post, "/clear")
     end
 
-    def raw
-      @data
-    end
+    alias_method :clear_queue, :clear
 
-    def [](key)
-      raw[key]
+    # Backward compatibility, better name is `delete`
+    def delete_queue
+      call_api_and_parse_response(:delete)
     end
 
-    def id
-      raw["id"]
+    # Backward compatibility
+    def delete(message_id, options = {})
+      # API does not accept any options
+      Message.new(self, {"id" => message_id}).delete
     end
 
-    def name
-      raw["name"]
+    def add_subscribers(subscribers)
+      call_api_and_parse_response(:post, "/subscribers", :subscribers => subscribers)
     end
 
-    def reload
-      load_queue(:force => true)
+    # `options` for backward compatibility
+    def add_subscriber(subscriber, options = {})
+      add_subscribers([subscriber])
     end
 
-    def messages
-      raw["messages"]
+    def remove_subscribers(subscribers)
+      call_api_and_parse_response(:delete,
+                                  "/subscribers",
+                                  {
+                                    :subscribers => subscribers,
+                                    :headers => {"Content-Type" => @client.content_type}
+                                  })
     end
 
-    # Used if lazy loading
-    def load_queue(options={})
-      return if @loaded && !options[:force]
-      q = @client.queues.get(:name => name)
-      @client.logger.debug "GOT Q: " + q.inspect
-      @data = q.raw
-      @loaded = true
-      q
+    def remove_subscriber(subscriber)
+      remove_subscribers([subscriber])
     end
 
-    def clear()
-      @client.queues.clear(:name => name)
-    end
+    def post_messages(payload, options = {})
+      batch = false
 
-    def delete_queue()
-      @client.queues.delete(:name => name)
-    end
+      msgs = if payload.is_a?(Array)
+               batch = true
+               # FIXME: This maybe better to process Array of Objects the same way as for single message.
+               #
+               #          payload.each_with_object([]) do |msg, res|
+               #            res << options.merge(:body => msg)
+               #          end
+               #
+               #        For now user must pass objects like `[{:body => msg1}, {:body => msg2}]`
+               payload.each_with_object([]) do |msg, res|
+                 res << msg.merge(options)
+               end
+             else
+               [ options.merge(:body => payload) ]
+             end
 
-    # Updates the queue object
-    #  :subscribers => url's to subscribe to
-    #  :push_type => multicast (default) or unicast.
-    def update_queue(options)
-      @client.queues.post(options.merge(:name => name))
-    end
+      # Do not instantiate response
+      res = call_api_and_parse_response(:post, "/messages", {:messages => msgs}, false)
 
-    def size
-      load_queue()
-      return raw["size"]
+      if batch
+        # FIXME: Return Array of ResponsBase instead, it seems more clear than raw response
+        #
+        #          res["ids"].each_with_object([]) do |id, responses|
+        #            responses << ResponseBase.new({"id" => id, "msg" => res["msg"]})
+        #          end
+        ResponseBase.new(res) # Backward capable
+      else
+        ResponseBase.new({"id" => res["ids"][0], "msg" => res["msg"]})
+      end
     end
 
-    def total_messages
-      load_queue()
-      return raw["total_messages"]
-    end
+    alias_method :post, :post_messages
 
-    def subscribers
-      load_queue()
-      return raw["subscribers"]
-    end
+    def get_messages(options = {})
+      if options.is_a?(String)
+        # assume it's an id
+        return Message.new(self, {"id" => options})
+      end
 
-    def add_subscriber(subscriber_hash, options={})
-      res = @client.post("#{@client.queues.path(:name => name)}/subscribers", :subscribers => [subscriber_hash])
-      res = @client.parse_response(res)
-      #p res
-      res
-    end
+      resp = call_api_and_parse_response(:get, "/messages", options)
 
-    def remove_subscriber(subscriber_hash)
-      res = @client.delete("#{@client.queues.path(:name => name)}/subscribers", {:subscribers => [subscriber_hash]}, {"Content-Type"=>@client.content_type})
-      res = @client.parse_response(res)
-      #p res
-      res
+      process_messages(resp["messages"], options)
     end
 
-    def post(body, options={})
-      @client.messages.post(body, options.merge(:queue_name => name))
-    end
+    alias_method :get, :get_messages
 
-    def get(options={})
-      @client.messages.get(options.merge(:queue_name => name))
-    end
+    # Backward compatibility
+    def messages ; self; end
+
+    def peek_messages(options = {})
+      resp = call_api_and_parse_response(:get, "/messages/peek", options)
 
-    def delete(id, options={})
-      @client.messages.delete(id, options.merge(:queue_name => name))
+      process_messages(resp["messages"], options)
     end
 
+    alias_method :peek, :peek_messages
 
-    # This will continuously poll for a message and pass it to the block. For example:
-    #
-    #     queue.poll { |msg| puts msg.body }
-    #
-    # options:
-    # - :sleep_duration=>seconds => time between polls if msg is nil. default 1.
-    # - :break_if_nil=>true/false => if true, will break if msg is nil (ie: queue is empty)
-    def poll(options={}, &blk)
+    def poll_messages(options = {}, &block)
       sleep_duration = options[:sleep_duration] || 1
+      
       while true
-        #p options
-        msg = get(options)
+        msg = get_messages(options.merge(:n => 1))
         if msg.nil?
-          if options[:break_if_nil]
-            break
-          else
-            sleep sleep_duration
-          end
+          options[:break_if_nil] ? break : sleep(sleep_duration)
         else
           yield msg
+          # Delete message after processing
           msg.delete
         end
       end
     end
 
-    def messages
-      Messages.new(client, self)
+    alias_method :poll, :poll_messages
+
+    def call_api_and_parse_response(meth, ext_path = "", options = {}, instantiate = true)
+      response = if meth.to_s == "delete"
+                   headers = options.delete(:headers) || options.delete("headers") || {}
+
+                   @client.parse_response(@client.send(meth, "#{path(ext_path)}", options, headers))
+                 else
+                   @client.parse_response(@client.send(meth, "#{path(ext_path)}", options))
+                 end
+      instantiate ? ResponseBase.new(response) : response
+    end
+
+    def method_missing(meth, *args)
+      # This is for reload queue info data when calling:
+      #   queue.id
+      #   queue.size
+      # etc.
+      if args.length == 0
+        res = info.send(meth)
+        res ? res : super
+      else
+        super
+      end
+    end
+
+    private
+
+    def path(ext_path)
+      "/#{CGI::escape(@name).gsub('+', '%20')}#{ext_path}"
+    end
+
+    def process_messages(messages, options)
+      multiple = wait_for_multiple?(options)
+
+      if messages.is_a?(Array) && messages.size > 0
+        if multiple
+          messages.each_with_object([]) do |m, msgs|
+            msgs << Message.new(self, m)
+          end
+        else
+          Message.new(self, messages[0])
+        end
+      else
+        multiple ? [] : nil
+      end
     end
 
+    def wait_for_multiple?(options)
+      options.is_a?(Hash) && ((options[:n] || options['n']).to_i > 1)
+    end
   end
 
 end

data/lib/iron_mq/response.rb

@@ -1,28 +1,29 @@
+require 'ostruct'
 
 module IronMQ
 
-  class ResponseBase
-
-    attr_reader :raw, :code
-
-    def initialize(raw, code=200)
-      @raw = raw
-      @code = code
+  class ResponseBase < OpenStruct
+    def initialize(data, code = 200)
+      super(data.merge(:code => code.to_i))
     end
 
     def [](key)
-      raw[key]
+      send(key.to_s)
     end
 
-    def id
-      raw["id"]
-    end
+    def raw
+      res = stringify_keys(marshal_dump)
+      # `code` is not part of response body
+      res.delete("code")
 
-    def msg
-      raw["msg"]
+      res
     end
 
-  end
+    private
 
+    def stringify_keys(hash)
+      hash.keys.each_with_object({}) { |k, res| res[k.to_s] = hash[k] }
+    end
+  end
 
-end
+end

data/lib/iron_mq/subscribers.rb

@@ -1,34 +1,25 @@
 module IronMQ
-  class Subscribers
-    def self.path(options)
-      path = "#{Messages.path(options)}/subscribers"
-      if options[:subscriber_id]
-        path << "/#{options[:subscriber_id]}"
-      end
-      path
-    end
-  end
 
   class Subscriber < ResponseBase
+    # `options` was kept for backward compatibility
     attr_accessor :options
 
-    def initialize(raw, message, options={})
-      super(raw)
+    def initialize(data, message, options = {})
+      super(data, 200)
       @message = message
       @options = options
     end
 
-    def delete(options={})
-      client = @message.messages.client
+    # `options` was kept for backward compatibility
+    def delete(options = {})
+      @message.call_api_and_parse_response(:delete, path)
+    end
 
-      options[:subscriber_id] ||= @raw["id"]
-      options[:msg_id] ||= @message.id
-      options[:project_id] ||= client.project_id
-      options[:queue_name] ||= client.queue_name
-      path = Subscribers.path(options)
-      raw = client.delete(path)
-      res = client.parse_response(raw)
-      return ResponseBase.new(res)
+    private
+
+    def path
+      "/subscribers/#{id}"
     end
   end
+
 end

data/lib/iron_mq/version.rb

@@ -1,4 +1,4 @@
 module IronMQ
-  VERSION = "3.1.0"
+  VERSION = "4.0.0"
 end
 

data/test/quick_run.rb

@@ -1,56 +1,86 @@
-require 'test_base'
+require 'quicky'
+require File.expand_path('test_base.rb', File.dirname(__FILE__))
 
-TIMES = 1
+TIMES = 10
 
 class QuickRun < TestBase
 
   def setup
     super
-    @client.queue_name = 'ironmq-gem_quick'
-    clear_queue
   end
 
-  def test_basics
+  def test_quick
+    queue_name = 'ironmq-gem_quick'
+    clear_queue(queue_name)
+    queue = @client.queue(queue_name)
 
-    TIMES.times do |i|
+    quicky = Quicky::Timer.new
+
+    # make connection
+    res2 = queue.get
+    # p res2
+
+    quicky.loop(:test_quick, TIMES, :warmup => 2) do |i|
       puts "==== LOOP #{i} =================================="
 
-      res = @client.messages.post("hello world!")
-      p res
-      assert res.id
-      post_id = res.id
-      assert res.msg
-
-      res = @client.messages.get()
-      p res
-      puts "post_id=" + post_id.inspect
-      assert res.id
-      assert_equal res.id, post_id
-      assert res.body
-
-      res = @client.messages.delete(res["id"])
-      p res
-      assert res.msg
-
-      res = @client.messages.get()
-      p res
-      assert res.nil?
-
-      res = @client.messages.post("hello world!", :queue_name => 'test2')
-      p res
-      assert res.id
-      assert res.msg
-
-      res = @client.messages.get(:queue_name => 'test2')
-      p res
-      assert res.id
-      assert res.body
-
-      res = res.delete
-      p res
+      post_id = nil
+      quicky.time(:post, :warmup => 2) 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
+
+      quicky.time(:get, :warmup => 2) do
+        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?)
+      end
+
+      quicky.time(:delete, :warmup => 2) do
+        res = queue.delete(post_id)
+        # p res
+        assert_not_nil res
+        assert !(res.msg.nil? || res.msg.empty?)
+      end
+
+      msg = queue.get
+      # p msg
+      assert_nil res
+
+
+      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
+    resp = queue.delete_queue
+    assert_equal 200, resp.code, "API must response 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
 
 

data/test/test_base.rb

@@ -30,26 +30,34 @@ class TestBase < Test::Unit::TestCase
 
     config = @config['iron']
     @host = "#{config['host'] || "mq-aws-us-east-1.iron.io"}"
+
     @client = IronMQ::Client.new(@config['iron'])
+
     Rest.logger.level = Logger::DEBUG # this doesn't work for some reason?
     IronCore::Logger.logger.level = Logger::DEBUG
-    @client.queue_name = 'ironmq-ruby-tests'
 
+    @queue_name = 'ironmq-ruby-tests' # default queue for tests
   end
 
 
   def clear_queue(queue_name=nil)
-    queue_name ||= @client.queue_name
+    queue_name ||= @queue_name
+
+    queue = @client.queue(queue_name)
+    queue.post("test")
+
     puts "clearing queue #{queue_name}"
-    @client.queue(queue_name).post("test")
-    @client.queue(queue_name).clear
+    queue.clear
     puts 'cleared.'
   end
 
   def assert_performance(time)
     start_time = Time.now
+
     yield
-    execution_time =  Time.now - start_time
+
+    execution_time = Time.now - start_time
+
     assert execution_time < time, "Execution time too big #{execution_time.round(2)}, should be #{time}"
   end