iron_mq 5.0.1 → 6.0.0.pre1

data/iron_mq.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency "iron_core", ">= 0.5.1"
 
   gem.add_development_dependency "test-unit"
-  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest", ">= 5.0"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "beanstalk-client"
   gem.add_development_dependency "uber_config"
@@ -29,5 +29,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "quicky"
   gem.add_development_dependency "iron_worker_ng"
   gem.add_development_dependency "go"
+  gem.add_development_dependency "parallel"
 end
 

data/lib/iron_mq/client.rb

@@ -11,40 +11,47 @@ module IronMQ
 
     def initialize(options={})
       default_options = {
-          :scheme => 'https',
-          :host => IronMQ::Client::AWS_US_EAST_HOST,
-          :port => 443,
-          :api_version => 1,
-          :user_agent => 'iron_mq_ruby-' + IronMQ::VERSION + ' (iron_core_ruby-' + IronCore.version + ')'
+          scheme: 'https',
+          host: IronMQ::Client::AWS_US_EAST_HOST,
+          port: 443,
+          api_version: 3,
+          user_agent: 'iron_mq_ruby-' + IronMQ::VERSION +
+                      ' (iron_core_ruby-' + IronCore.version + ')'
       }
 
-      super('iron', 'mq', options, default_options, [:project_id, :token, :api_version])
+      super('iron', 'mq', options, default_options,
+            [:project_id, :token, :api_version])
 
-      IronCore::Logger.error 'IronMQ', "Token is not set", IronCore::Error if @token.nil?
+      if @keystone.nil?
+        if @token.nil?
+          IronCore::Logger.error 'IronMQ', 'Token is not set', IronCore::Error
+        end
 
-      check_id(@project_id, 'project_id')
+        check_id(@project_id, 'project_id')
+      end
 
       @logger = Logger.new(STDOUT)
       @logger.level = Logger::INFO
     end
 
     def headers
-      super.merge({'Authorization' => "OAuth #{@token}"})
+      super.merge({'Authorization' => "OAuth #{@token_provider.nil? ? @token : @token_provider.token}"})
     end
 
     def base_url
-      @base_url = "#{super}#{@api_version}/projects/#{@project_id}/queues"
+      @base_url ||= "#{super}#{@api_version}/projects/#{@project_id}/queues"
     end
 
     def queues_list(options = {})
       is_raw = [options.delete(:raw),
                 options.delete('raw')].compact.first
       response = parse_response(get('', options)) # GET base_url
+      # p response
       # returns list of evaluated queues
       if is_raw
         response.map{ |q_info| ResponseBase.new(q_info) }
       else
-        response.map{ |q_info| Queue.new(self, q_info["name"]) }
+        response['queues'].map { |q_info| Queue.new(self, q_info['name']) }
       end
     end
 
@@ -58,11 +65,11 @@ module IronMQ
     alias_method :queue, :queues_get
 
     # Backward compatibility for
-    #   client.queues.get(:name => "my_queue")
-    #   client.queues.get("name" => "my_queue")
+    #   client.queues.get(name: 'my_queue')
+    #   client.queues.get('name' => 'my_queue')
     def get(*args)
       if args.size == 1 && args[0].is_a?(Hash)
-        queue_name = (args[0][:name] || args[0]["name"]).to_s
+        queue_name = (args[0][:name] || args[0]['name']).to_s
         queue_name.empty? ? super : queues_get(queue_name)
       else
         super
@@ -76,6 +83,23 @@ module IronMQ
     def queues
       self
     end
+
+    def create_queue(queue_name, options)
+      response = self.put("/#{CGI::escape(queue_name).gsub('+', '%20')}",
+                          {queue: options})
+      queue_hash = JSON.parse(response.body.to_s)
+
+      ResponseBase.new(queue_hash['queue'])
+    end
+
+    def update_queue(queue_name, options)
+      response = self.patch("/#{CGI::escape(queue_name).gsub('+', '%20')}",
+                            {queue: options})
+      queue_hash = JSON.parse(response.body.to_s)
+
+      ResponseBase.new(queue_hash['queue'])
+    end
+
   end
 
 end

data/lib/iron_mq/messages.rb

@@ -30,17 +30,25 @@ module IronMQ
       @raw['reserved_count']
     end
 
+    def reservation_id
+      @raw['reservation_id']
+    end
+
+    def push_statuses
+      @raw['push_statuses']
+    end
+
     def touch
-      call_api_and_parse_response(:post, "/touch")
+      call_api_and_parse_response(:post, '/touch')
     end
 
     def release(options = {})
-      call_api_and_parse_response(:post, "/release", options)
+      call_api_and_parse_response(:post, '/release', options)
     end
 
     # `options` was kept for backward compatibility
     def subscribers(options = {})
-      response = call_api_and_parse_response(:get, "/subscribers", {}, false)
+      response = call_api_and_parse_response(:get, '/subscribers', {}, false)
 
       response['subscribers'].map { |s| Subscriber.new(s, self, options) }
     end
@@ -49,16 +57,22 @@ module IronMQ
       call_api_and_parse_response(:delete)
     rescue Rest::HttpError => ex
       #if ex.code == 404
-      #  Rest.logger.info("Delete got 404, safe to ignore.")
+      #  Rest.logger.info('Delete got 404, safe to ignore.')
       #  # return ResponseBase as normal
-      #  ResponseBase.new({"msg" => "Deleted"}, 404)
+      #  ResponseBase.new({'msg' => 'Deleted'}, 404)
       #else
-        raise ex
+      raise ex
       #end
     end
 
-    def call_api_and_parse_response(meth, ext_path = "", options = {}, instantiate = true)
-      @queue.call_api_and_parse_response(meth, "#{path(ext_path)}", options, instantiate)
+    def call_api_and_parse_response(meth, ext_path = '',
+                                    options = {}, instantiate = true)
+      if self.reservation_id && !self.reservation_id.empty?
+        options[:reservation_id] = self.reservation_id
+      end
+      @queue.call_api_and_parse_response(meth,
+                                         "#{path(ext_path)}",
+                                         options, instantiate)
     end
 
     private

data/lib/iron_mq/queues.rb

@@ -18,49 +18,46 @@ module IronMQ
     def load
       reload if @raw.nil?
 
-      @raw
+      @raw['queue']
     end
 
     def reload
-      @raw = call_api_and_parse_response(:get, "", {}, false, true)
+      @raw = call_api_and_parse_response(:get, '', {}, false, true)
       self
     end
 
     def id
-      load
-      @raw['id']
+      load['id']
     end
 
     def size
-      load
-      @raw['size'].to_i
+      load['size'].to_i
     end
 
     def total_messages
-      load
-      @raw['total_messages'].to_i
+      load['total_messages'].to_i
     end
 
-    def push_type
-      load
-      @raw['push_type']
+    def type
+      load['type']
     end
 
     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?)
+      ['multicast', 'unicast'].include?(type)
     end
 
-    def update(options)
-      call_api_and_parse_response(:post, "", options)
+    def push_info
+      load['push']
+    end
+
+    def update(options={})
+      call_api_and_parse_response(:put, '', {queue: options})
     end
 
     alias_method :update_queue, :update
 
     def clear
-      call_api_and_parse_response(:post, "/clear", {}, false, true)
+      call_api_and_parse_response(:delete, '/messages', {}, false, true)
     end
 
     alias_method :clear_queue, :clear
@@ -72,27 +69,40 @@ module IronMQ
       return r
     rescue Rest::HttpError => ex
       #if ex.code == 404
-      #  Rest.logger.info("Delete got 404, safe to ignore.")
+      #  Rest.logger.info('Delete got 404, safe to ignore.')
       #  # return ResponseBase as normal
-      #  ResponseBase.new({"msg" => "Deleted"}, 404)
+      #  ResponseBase.new({'msg' => 'Deleted'}, 404)
       #else
         raise ex
       #end
     end
 
     # Backward compatibility
-    def delete(message_id, options = {})
+    def delete(message_id, reservation_id = nil)
       # API does not accept any options
-      Message.new(self, {"id" => message_id}).delete
+      options = {}
+      options['id'] = message_id
+      unless reservation_id.nil?
+        options['reservation_id'] = reservation_id
+      end
+      Message.new(self, options).delete
     end
 
     # Accepts an array of message ids
     def delete_messages(ids)
-      call_api_and_parse_response(:delete, "/messages", :ids => ids)
+      call_api_and_parse_response(:delete, '/messages', ids: ids)
+    end
+
+    def delete_reserved_messages(messages)
+      ids = messages.map do |message|
+        {id: message.id, reservation_id: message.reservation_id}
+      end
+
+      call_api_and_parse_response(:delete, '/messages', ids: ids)
     end
 
     def add_subscribers(subscribers)
-      call_api_and_parse_response(:post, "/subscribers", :subscribers => subscribers)
+      call_api_and_parse_response(:post, '/subscribers',{subscribers: subscribers})
     end
 
     # `options` for backward compatibility
@@ -102,10 +112,12 @@ module IronMQ
 
     def remove_subscribers(subscribers)
       call_api_and_parse_response(:delete,
-                                  "/subscribers",
+                                  '/subscribers',
                                   {
-                                      :subscribers => subscribers,
-                                      :headers => {"Content-Type" => @client.content_type}
+                                    subscribers: subscribers,
+                                    headers: {
+                                      'Content-Type' => @client.content_type
+                                    }
                                   })
     end
 
@@ -113,31 +125,53 @@ module IronMQ
       remove_subscribers([subscriber])
     end
 
+    def replace_subscribers(subscribers)
+      call_api_and_parse_response(:put,
+                                  '/subscribers',
+                                  {
+                                      subscribers: subscribers,
+                                      headers: {
+                                          'Content-Type' => @client.content_type
+                                      }
+                                  })
+    end
+
+    def replace_subscriber(subscriber)
+      replace_subscribers([subscriber])
+    end
+
     # `options` was kept for backward compatibility
     def subscribers(options = {})
       load
-      if @raw['subscribers']
-        return @raw['subscribers'].map { |s| Subscriber.new(s, self, options) }
-      end
-      []
-    end
+      return [] if info['push'].nil? || info['push']['subscribers'].nil?
 
-    def add_alert(alert)
-      add_alerts([alert])
+      info['push']['subscribers'].map { |s| Subscriber.new(s, self, options) }
     end
 
     def add_alerts(alerts)
-      call_api_and_parse_response(:post, '/alerts', :alerts => alerts)
+      call_api_and_parse_response(:patch, '', queue: {alerts: alerts})
+    end
+
+    def add_alert(alert)
+      add_alerts([alert])
     end
 
     def remove_alerts(alerts)
-      call_api_and_parse_response(:delete, '/alerts', :alerts => alerts)
+      call_api_and_parse_response(:delete, '/alerts', alerts: alerts)
     end
 
     def remove_alert(alert)
       remove_alerts([alert])
     end
 
+    def replace_alerts(alerts)
+      call_api_and_parse_response(:put, '/alerts', alerts: alerts)
+    end
+
+    def clear_alerts
+      replace_alerts([])
+    end
+
     def alerts
       load
       return nil unless @raw['alerts']
@@ -159,44 +193,42 @@ module IronMQ
                #        For now user must pass objects like `[{:body => msg1}, {:body => msg2}]`
                payload.map { |msg| msg.merge(options) }
              else
-               [options.merge(:body => payload)]
+               [options.merge(body: payload)]
              end
 
       # Do not instantiate response
-      res = call_api_and_parse_response(:post, "/messages", {:messages => msgs}, false)
+      res = call_api_and_parse_response(:post, '/messages',
+                                        {messages: msgs}, false)
 
       if instantiate
         n = batch ? 2 : 1
-        msg_ids = res["ids"].map { |id| {"id" => id} }
+        msg_ids = res['ids'].map { |id| {'id' => id} }
 
-        process_messages(msg_ids, {:n => n})
+        process_messages(msg_ids, {n: n})
       else
         if batch
           # FIXME: Return Array of ResponseBase instead, it seems more clear than raw response
           #
-          #          res["ids"].map { |id| ResponseBase.new({"id" => id, "msg" => res["msg"]}) }
+          #          res['ids'].map { |id| ResponseBase.new({'id' => id, 'msg' => res['msg']}) }
           #
           ResponseBase.new(res) # Backward capable
         else
-          ResponseBase.new({"id" => res["ids"][0], "msg" => res["msg"]})
+          ResponseBase.new({'id' => res['ids'][0], 'msg' => res['msg']})
         end
       end
     end
 
     alias_method :post, :post_messages
 
-    def get_messages(options = {})
-      if options.is_a?(String)
-        # assume it's an id
-        return Message.new(self, {"id" => options})
-      end
-
-      resp = call_api_and_parse_response(:get, "/messages", options, false)
-
-      process_messages(resp["messages"], options)
+    def reserve_messages(options = {})
+      resp = call_api_and_parse_response(:post, '/reservations', options, false)
+      process_messages(resp['messages'], options)
     end
 
-    alias_method :get, :get_messages
+    # backwards compatibility
+    alias_method :get, :reserve_messages
+    alias_method :get_messages, :reserve_messages
+    alias_method :reserve, :reserve_messages
 
     # Backward compatibility
     def messages
@@ -205,13 +237,13 @@ module IronMQ
 
     def get_message(id)
       resp = call_api_and_parse_response(:get, "/messages/#{id}", {}, false)
-      Message.new(self, resp)
+      Message.new(self, resp['message'])
     end
 
     def peek_messages(options = {})
-      resp = call_api_and_parse_response(:get, "/messages/peek", options)
+      resp = call_api_and_parse_response(:get, '/messages', options)
 
-      process_messages(resp["messages"], options)
+      process_messages(resp['messages'], options)
     end
 
     alias_method :peek, :peek_messages
@@ -233,17 +265,24 @@ module IronMQ
 
     alias_method :poll, :poll_messages
 
-    def call_api_and_parse_response(meth, ext_path = "", options = {}, instantiate = true, ignore404 = false)
-      r = nil
-      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
-      r = instantiate ? ResponseBase.new(response) : response
-      r
+    def call_api_and_parse_response(meth, ext_path = '', options = {},
+                                    instantiate = true, ignore404 = false)
+      response =
+        if meth.to_s == 'delete'
+          headers = options.delete(:headers) ||
+                    options.delete('headers') ||
+                    Hash.new
+          headers['Content-Type'] = 'application/json'
+          @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
 
     private