iron 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+pkg/
+doc
+.idea
+log
+test/config.yml
+*.sublime*

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    iron (0.0.1)
+      iron_core (>= 0.4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    beanstalk-client (1.1.1)
+    concur (1.0.0)
+      faraday
+      faraday
+    faraday (0.8.4)
+      multipart-post (~> 1.1)
+    ffi (1.1.5)
+    iron_core (0.4.3)
+      rest (>= 2.0.2)
+    mime-types (1.19)
+    minitest (4.1.0)
+    multipart-post (1.1.5)
+    net-http-persistent (2.8)
+    rake (0.9.2.2)
+    rest (2.0.4)
+      net-http-persistent
+      rest-client (>= 0.3.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    test-unit (2.5.2)
+    typhoeus (0.4.2)
+      ffi (~> 1.0)
+      mime-types (~> 1.18)
+    uber_config (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  beanstalk-client
+  concur
+  iron!
+  minitest
+  net-http-persistent
+  rake
+  test-unit
+  typhoeus
+  uber_config

data/README.md

@@ -0,0 +1,60 @@
+IronMQ Ruby Client
+-------------
+
+Getting Started
+==============
+
+1\. Install the gem:
+
+    gem install iron_mq
+
+2\. Setup your Iron.io credentials: http://dev.iron.io/articles/configuration/
+
+3\. Create an IronMQ client object:
+
+    @ironmq = IronMQ::Client.new()
+
+
+The Basics
+=========
+
+**Get a Queue object**
+
+You can have as many queues as you want, each with their own unique set of messages.
+
+    @queue = @ironmq.queue("my_queue")
+
+Now you can use it:
+
+**Post** a message on the queue:
+
+    @queue.post("hello world!")
+
+**Get** a message off the queue:
+
+    msg = @queue.get()
+    puts msg.body
+
+When you pop/get a message from the queue, it will NOT be deleted. It will eventually go back onto the queue after
+a timeout if you don't delete it (default timeout is 10 minutes).
+
+**Delete** a message from the queue:
+
+    msg.delete # or @queue.delete(msg.id)
+
+Be sure to delete a message from the queue when you're done with it.
+
+**Poll** for messages:
+
+    @queue.poll do |msg|
+      puts msg.body
+    end
+
+Polling will automatically delete the message at the end of the block.
+
+Queue Information
+=================
+
+    queue = @client.queue("my_queue")
+    puts "size: #{queue.size}"
+

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "iron_mq #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/iron_mq.gemspec

@@ -0,0 +1,31 @@
+require File.expand_path('../lib/iron_mq/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Travis Reeder"]
+  gem.email         = ["treeder@gmail.com"]
+  gem.description   = "Ruby client for IronMQ by www.iron.io"
+  gem.summary       = "Ruby client for IronMQ by www.iron.io"
+  gem.homepage      = "https://github.com/iron-io/iron_mq_ruby"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "iron"
+  gem.require_paths = ["lib"]
+  gem.version       = IronMQ::VERSION
+
+  gem.required_rubygems_version = ">= 1.3.6"
+  gem.required_ruby_version = Gem::Requirement.new(">= 1.9")
+  gem.add_runtime_dependency "iron_core", ">= 0.4.2"
+
+  gem.add_development_dependency "test-unit"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "beanstalk-client"
+  gem.add_development_dependency "uber_config"
+  gem.add_development_dependency "typhoeus"
+  gem.add_development_dependency "concur"
+  gem.add_development_dependency "net-http-persistent"
+
+end
+

data/lib/iron_mq.rb

@@ -0,0 +1,5 @@
+require 'rest'
+require_relative 'iron_mq/queues'
+require_relative 'iron_mq/messages'
+require_relative 'iron_mq/client'
+require_relative 'iron_mq/version'

data/lib/iron_mq/client.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+require 'iron_core'
+
+module IronMQ
+
+  class Client < IronCore::Client
+    AWS_US_EAST_HOST = 'mq-aws-us-east-1.iron.io'
+
+    attr_accessor :queue_name, :logger
+
+    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 + ')',
+          :queue_name => 'default'
+      }
+
+      super('iron', 'mq', options, default_options, [:project_id, :token, :api_version, :queue_name])
+
+      IronCore::Logger.error 'IronMQ', "Token is not set", IronCore::Error if @token.nil?
+
+      check_id(@project_id, 'project_id')
+
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    def headers
+      super.merge({'Authorization' => "OAuth #{@token}"})
+    end
+
+    def base_url
+      super + @api_version.to_s + '/'
+    end
+
+    def queue(name)
+      return Queue.new(self, {"name" => name})
+    end
+
+    def messages
+      return Messages.new(self)
+    end
+
+    def queues
+      return Queues.new(self)
+    end
+  end
+end

data/lib/iron_mq/messages.rb

@@ -0,0 +1,123 @@
+require 'cgi'
+
+module IronMQ
+  class Messages
+
+    attr_accessor :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def path(options={})
+      path = "projects/#{@client.project_id}/queues/#{CGI::escape(options[:queue_name] || options['queue_name'] || @client.queue_name)}/messages"
+    end
+
+    # options:
+    #  :queue_name => can specify an alternative queue name
+    #  :timeout => amount of time before message goes back on the queue
+    def get(options={})
+      res = @client.parse_response(@client.get(path(options), options))
+      ret = []
+      res["messages"].each do |m|
+        ret << Message.new(self, m, options)
+      end
+      if options[:n] || options['n']
+        return ret
+      else
+        if ret.size > 0
+          return ret[0]
+        else
+          return nil
+        end
+      end
+    end
+
+    # options:
+    #  :queue_name => can specify an alternative queue name
+    #  :delay => time to wait before message will be available on the queue
+    #  :timeout => The time in seconds to wait after message is taken off the queue, before it is put back on. Delete before :timeout to ensure it does not go back on the queue.
+    #  :expires_in => After this time, message will be automatically removed from the queue.
+    def post(payload, options={})
+      batch = false
+      if payload.is_a?(Array)
+        batch = true
+        msgs = payload
+      else
+        options[:body] = payload
+        msgs = []
+        msgs << options
+      end
+      to_send = {}
+      to_send[:messages] = msgs
+      res = @client.parse_response(@client.post(path(options), to_send))
+      if batch
+        return res
+      else
+        return ResponseBase.new({"id"=>res["ids"][0], "msg"=>res["msg"]})
+      end
+    end
+
+    def delete(message_id, options={})
+      path2 = "#{self.path(options)}/#{message_id}"
+      res = @client.parse_response(@client.delete(path2))
+      return ResponseBase.new(res)
+    end
+
+    def release(message_id, options={})
+      path2 = "#{self.path(options)}/#{message_id}/release"
+      res = @client.parse_response(@client.post(path2, options))
+      return ResponseBase.new(res)
+    end
+
+  end
+
+  class ResponseBase
+
+    def initialize(res)
+      @data = res
+    end
+
+    def raw
+      @data
+    end
+
+    def [](key)
+      raw[key]
+    end
+
+    def id
+      raw["id"]
+    end
+
+    def msg
+      raw["msg"]
+    end
+
+  end
+
+  class Message < ResponseBase
+
+    def initialize(messages, res, options={})
+      super(res)
+      @messages = messages
+      @options = options
+    end
+
+
+    def body
+      raw["body"]
+    end
+
+    def delete
+      @messages.delete(self.id, @options)
+    end
+
+    def release(options={})
+      options2 = options || {}
+      options2 = options.merge(@options) if @options
+      @messages.release(self.id, options2)
+    end
+  end
+
+end

data/lib/iron_mq/queues.rb

@@ -0,0 +1,169 @@
+require 'cgi'
+
+module IronMQ
+  class Queues
+
+    attr_accessor :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def path(options={})
+      path = "projects/#{@client.project_id}/queues"
+      if options[:name]
+        path << "/#{CGI::escape(options[:name])}"
+      end
+      path
+    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
+    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
+    end
+
+    def delete(options={})
+      @client.logger.debug "Deleting queue #{options[:name]}"
+      r1 = @client.delete("#{path(options)}", options)
+      @client.logger.debug "Delete result: #{r1}"
+      r1
+    end
+
+    # options:
+    #  :name => can specify an alternative queue name
+    def get(options={})
+      options[:name] ||= @client.queue_name
+      res = @client.parse_response(@client.get("#{path(options)}"))
+      return Queue.new(@client, res)
+    end
+
+    # Update a queue
+    # options:
+    #  :name => if not specified, will use global queue name
+    #  :subscriptions => url's to subscribe to
+    def post(options={})
+      options[:name] ||= @client.queue_name
+      res = @client.parse_response(@client.post(path(options), options))
+      res
+      p res
+
+    end
+
+
+  end
+
+  class Queue
+
+    def initialize(client, res)
+      @client = client
+      @data = res
+    end
+
+    def raw
+      @data
+    end
+
+    def [](key)
+      raw[key]
+    end
+
+    def id
+      raw["id"]
+    end
+
+    def name
+      raw["name"]
+    end
+
+    def reload
+      load_queue
+    end
+
+    # Used if lazy loading
+    def load_queue
+      q = @client.queues.get(:name => name)
+      @client.logger.debug "GOT Q: " + q.inspect
+      @data = q.raw
+      q
+    end
+
+    def clear()
+      @client.queues.clear(:name => name)
+    end
+
+    def delete_queue()
+      @client.queues.delete(:name=>name)
+    end
+
+    def size
+      return raw["size"] if raw["size"]
+      return @size if @size
+      q = load_queue()
+      @size = q.size
+      @size
+    end
+
+    def total_messages
+      return raw["total_messages"] if raw["total_messages"]
+      return @total_messages if @total_messages
+      q = load_queue()
+      @total_messages = q.total_messages
+      @total_messages
+    end
+
+    def post(body, options={})
+      @client.messages.post(body, options.merge(:queue_name => name))
+    end
+
+    def get(options={})
+      @client.messages.get(options.merge(:queue_name => name))
+    end
+
+    # 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)
+      sleep_duration = options[:sleep_duration] || 1
+      while true
+        #p options
+        msg = get(options)
+        if msg.nil?
+          if options[:break_if_nil]
+            break
+          else
+            sleep sleep_duration
+          end
+        else
+          yield msg
+          msg.delete
+        end
+      end
+    end
+
+    def delete(id, options={})
+      @client.messages.delete(id, options.merge(:queue_name => name))
+    end
+
+  end
+
+end
+