iron 0.0.1

data/lib/iron_mq/version.rb

@@ -0,0 +1,3 @@
+module IronMQ
+  VERSION = "0.0.1"
+end

data/test/long_run.rb

@@ -0,0 +1,31 @@
+require 'yaml'
+require 'concur'
+require 'uber_config'
+begin
+  require File.join(File.dirname(__FILE__), '..', 'lib', 'iron_mq')
+rescue Exception => ex
+  puts "Could NOT load current iron_mq: " + ex.message
+  raise ex
+end
+
+require_relative 'long_run_worker'
+
+@config = UberConfig.load
+@num_to_add = 10000
+
+p @config
+
+worker = LongRunWorker.new
+worker.config = @config
+worker.queue_name = "concur8"
+worker.num_threads = 100
+worker.num_to_add = @num_to_add
+worker.skip_get_and_delete = false
+worker.run
+#worker.queue
+#status = worker.wait_until_complete
+#p status
+#puts worker.get_log
+
+
+

data/test/long_run_worker.rb

@@ -0,0 +1,81 @@
+require 'concur'
+require 'iron_mq'
+
+class LongRunWorker
+
+  attr_accessor :config, :num_to_add, :queue_name, :skip_get_and_delete, :num_threads
+
+  def run
+
+    @client = IronMQ::Client.new(@config['iron'])
+    queue = @client.queue(queue_name)
+
+    @error_count = 0
+
+    start = Time.now
+    puts "Queuing #{@num_to_add} items at #{start}..."
+    executor = Concur::Executor.new_thread_pool_executor(num_threads || 20)
+    @num_to_add.times do |i|
+      task = executor.execute do
+        begin
+          puts "POST #{i}..."
+          res = queue.post("hello world! #{i}")
+        rescue => ex
+          puts "ERROR! #{ex.class.name}: #{ex.message} -- #{ex.backtrace.inspect}"
+          @error_count += 1
+          raise ex
+        end
+      end
+    end
+
+    i = 0
+    while executor.queue_size > 0 do
+      i += 1
+      puts "waiting #{i}, queue size=#{executor.queue_size}"
+      sleep 2
+    end
+    put_time = (Time.now.to_f - start.to_f)
+    sleep 1
+    puts "Finished pushing in #{put_time} seconds"
+
+    queue = @client.queue(queue_name)
+    queue_size_after_push = queue.size
+    puts "QUEUE SIZE: #{queue_size_after_push}"
+
+    #exit if true
+
+    if skip_get_and_delete
+      start = Time.now
+      puts "Getting and deleting #{@num_to_add} items at #{start}..."
+      @num_to_add.times do |i|
+        task = executor.execute do
+          puts "GET #{i}..."
+          res = queue.get()
+          p res
+          puts "DELETE #{i}..."
+          res = queue.delete(res.id)
+          p res
+        end
+      end
+      i = 0
+      while executor.queue_size > 0 do
+        i += 1
+        puts "waiting #{i}, queue size=#{executor.queue_size}"
+        sleep 2
+      end
+      sleep 1
+    end
+
+    queue = @client.queue(queue_name)
+
+    puts "Finished pushing #{@num_to_add} items in #{put_time} seconds."
+    puts "QUEUE SIZE after push: #{queue_size_after_push}"
+    puts "Finished getting and deleting #{@num_to_add} items in #{(Time.now.to_f - start.to_f)} seconds."
+    puts "QUEUE SIZE after delete: #{queue.size}"
+    puts "Errors: #{@error_count}"
+
+    executor.shutdown
+
+  end
+
+end

data/test/quick_run.rb

@@ -0,0 +1,52 @@
+require_relative 'test_base'
+
+class QuickRun < TestBase
+
+  def setup
+    super
+    @client.queue_name = 'ironmq-gem_quick'
+    clear_queue
+  end
+
+  def test_basics
+
+    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
+
+
+  end
+
+
+end
+

data/test/schedule_abt.rb

@@ -0,0 +1,27 @@
+require 'abt'
+require 'time'
+require_relative 'test_base'
+
+# Config for abt tests to run on IronWorker
+@abt_config = YAML::load_file(File.expand_path(File.join("~", "Dropbox", "configs", "abt", "test", "config.yml")))
+IronWorker.configure do |c|
+  c.token = @abt_config['iron']['token']
+  c.project_id = @abt_config['iron']['project_id']
+end
+
+# IronWorker.logger.level = Logger::DEBUG
+# Config to run iron_mq_ruby tests
+@test_config = TestBase.load_config
+
+worker = Abt::AbtWorker.new
+worker.git_url = "git://github.com/iron-io/iron_mq_ruby.git"
+worker.test_config = @test_config
+worker.add_notifier(:hip_chat_notifier, :config=>@abt_config["hipchat"])
+worker.upload # Must upload after adding notifier to ensure it's merged
+#worker.run_local
+#worker.queue
+#status = worker.wait_until_complete
+#p status
+#puts "LOG:"
+#puts worker.get_log
+#worker.schedule(:start_at=>Time.now.iso8601, :run_every=>3600)

data/test/test_base.rb

@@ -0,0 +1,44 @@
+gem 'test-unit'
+require 'test/unit'
+require 'yaml'
+require 'uber_config'
+begin
+  require File.join(File.dirname(__FILE__), '../lib/iron_mq')
+rescue Exception => ex
+  puts "Could NOT load current iron_mq: " + ex.message
+  raise ex
+end
+
+
+class TestBase < Test::Unit::TestCase
+  def setup
+    puts 'setup'
+    # check multiple config locations
+    @config = UberConfig.load
+    puts "config=" + @config.inspect
+    @client = IronMQ::Client.new(@config['iron'])
+    IronCore::Logger.logger.level = Logger::DEBUG
+    @client.queue_name = 'ironmq-ruby-tests'
+
+  end
+
+
+  def clear_queue(queue_name=nil)
+    queue_name ||= @client.queue_name
+    puts "clearing queue #{queue_name}"
+    while res = @client.messages.get(:queue_name=>queue_name)
+      p res
+      puts res.body.to_s
+      res.delete
+    end
+    puts 'cleared.'
+  end
+
+  def assert_performance(time)
+    start_time = Time.now
+    yield
+    execution_time =  Time.now - start_time
+    assert execution_time < time, "Execution time too big #{execution_time.round(2)}, should be #{time}"
+  end
+
+end

data/test/test_beanstalkd.rb

@@ -0,0 +1,222 @@
+gem 'test-unit'
+require 'test/unit'
+require 'beanstalk-client'
+require 'yaml'
+require_relative 'test_base'
+
+class BeanstalkTests < TestBase
+  def setup
+    super
+
+    config = @config['iron']
+    @host = "#{config['host'] || "mq-aws-us-east-1.iron.io"}:#{config['beanstalkd_port'] || 11300}"
+    puts "beanstalkd url: #{@host}"
+    @skip = @host.include? 'rackspace'
+    return if @skip # bypass these tests if rackspace
+    @beanstalk = Beanstalk::Connection.new(@host)
+    @beanstalk.put("oauth #{config['token']} #{config['project_id']}")
+
+    clear_tube('default')
+  end
+
+  def test_basics
+    omit_if @skip # bypass this test if rackspace
+    puts 'test_basics3'
+
+    queue_name = "beanstalk_test"
+    clear_queue(queue_name)
+    @beanstalk.use(queue_name)
+    @beanstalk.watch(queue_name)
+
+    #puts 'reserving...'
+    #job = beanstalk.reserve(1)
+    #p job
+    #exit
+
+    msg = "hello #{Time.now}"
+    puts "msg=" + msg
+    @beanstalk.put(msg)
+    job = @beanstalk.reserve
+    p job
+    p job.body
+    assert_equal msg, job.body, "job.body #{job.body} not the same as the one we put on #{msg}."
+    job.delete
+    job = assert_raise(Beanstalk::TimedOut) {
+      @beanstalk.reserve(1)
+    }
+
+    hasher = {:x => 1, :y => "hello", "yo" => "scooby doo"}
+    @beanstalk.put(hasher.to_json)
+    job = @beanstalk.reserve(1)
+    got = JSON.parse(job.body)
+    assert got.is_a?(Hash)
+    assert_equal hasher[:x], got['x']
+    job.delete
+
+    msg = "hello there\nthis is a new line"
+    @beanstalk.put(msg)
+    job = @beanstalk.reserve(1)
+    assert_equal msg, job.body, "#{job.body} does not equal #{msg}"
+    job.delete
+  end
+
+  def clear_tube(tube)
+    omit_if @skip # bypass this test if rackspace
+    watched = @beanstalk.list_tubes_watched(true)
+    puts 'watched: ' + watched.inspect
+    @beanstalk.watch(tube)
+    puts "clear #{tube}"
+    # clean up anything in queue
+    while x = reserve(0) do
+      puts 'deleting ' + x.inspect
+      x.delete
+    end
+    puts 'done clearing'
+    @beanstalk.ignore(tube) if not watched.include?(tube)
+  end
+
+  def test_basics2
+    omit_if @skip # bypass this test if rackspace
+    puts 'test_basics'
+    msg = "hello #{Time.now}"
+    @beanstalk.put(msg)
+    job = reserve
+    puts 'first job: ' + job.inspect
+    puts "body=" + job.body # prints "hello"
+    assert_equal msg, job.body, "body not the same as message."
+    job.delete
+    puts 'deleted'
+    job = reserve(1)
+    puts 'second job = ' + job.inspect
+    assert job.nil?, "second job was not nil " + job.inspect
+
+    hasher = {:x => 1, :y => "hello", "yo" => "scooby doo"}
+    @beanstalk.put(hasher.to_json)
+    job = reserve(1)
+    got = JSON.parse(job.body)
+    puts 'got=' + got.inspect
+    assert got.is_a?(Hash)
+    assert_equal hasher[:x], got['x']
+    job.delete
+
+    msg = "hello there\nthis is a new line"
+    @beanstalk.put(msg)
+    job = reserve(1)
+    assert_equal msg, job.body, "#{job.body} does not equal #{msg}"
+    job.delete
+  end
+
+  def test_timeout
+    omit_if @skip # bypass this test if rackspace
+    puts 'test_timeout'
+    msg = "timeout message #{Time.now}"
+    # timeout of 10 seconds
+    res = @beanstalk.put(msg, 65536, 0, 10)
+    puts 'result: ' + res.inspect
+    job = reserve(0)
+    puts 'first timeout job: ' + job.inspect
+    assert_equal msg, job.body, "body not the same as message."
+
+    niljob = reserve(0)
+    assert niljob.nil?, "job is not nil! #{niljob.inspect}"
+
+    # let it time out
+    sleep 10
+    job = reserve(0)
+    puts 'second delayed job: ' + job.inspect
+    assert_not_nil job, "job is nil"
+    assert_equal msg, job.body, "body not the same as message."
+    job.delete
+  end
+
+  def test_delay
+    omit_if @skip # bypass this test if rackspace
+    puts 'test_delay'
+    msg = "delayed message #{Time.now}"
+    # delay of 2 seconds
+    @beanstalk.put(msg, 65536, 2)
+
+    # delay should still be in effect, so job is nil
+    job = reserve(0)
+    assert job.nil?, "job is not nil"
+
+    # wait for delay to expire
+    sleep 2
+    job = reserve(0)
+    assert_not_nil job, "job is nil"
+    assert_equal msg, job.body, "body not the same as message."
+    job.delete
+  end
+
+  def tube_message(tube)
+    omit_if @skip # bypass this test if rackspace
+    "hello #{tube}! #{Time.now}"
+  end
+
+  def reserve(timeout=nil)
+    omit_if @skip # bypass this test if rackspace
+    begin
+      job = @beanstalk.reserve(timeout)
+      puts 'got job: ' + job.inspect
+      return job
+    rescue Beanstalk::TimedOut => ex
+      puts "Timed out: #{ex.message}"
+      return nil
+    end
+  end
+
+  def test_tubes
+    omit_if @skip # bypass this test if rackspace
+    clear_tube('youtube')
+    tube1 = 'default'
+    msg1 = tube_message(tube1)
+    @beanstalk.put(msg1)
+    tube2 = 'youtube'
+    @beanstalk.use(tube2) # switch tubes to put messages on
+    msg2 = tube_message(tube2)
+    @beanstalk.put(msg2)
+                          # now we have a single message in two different tubes.
+                          # let's first try to ensure we only get the one off the default tube.
+    job = reserve(1)
+    assert_equal msg1, job.body, "body #{job.body.to_s} does not equal #{msg1}"
+    job.delete
+                          # second message should not come off since we're not watching that tube.
+    job = reserve(1)
+    assert job.nil?, "second job was not nil " + job.inspect
+
+    @beanstalk.watch(tube2)
+    job = reserve(1)
+    assert_equal msg2, job.body, "body #{job.body.to_s} does not equal #{msg2}"
+    job.delete
+
+    # Now that we're watching both tubes we should get messages put into either.
+    @beanstalk.use(tube1)
+    msg3 = tube_message(tube1)
+    @beanstalk.put(msg3)
+    job = reserve(1)
+    assert_equal msg3, job.body
+    job.delete
+
+    # now put one in default and one in tube2, then we'll ignore default
+    msg1 = tube_message(tube1)
+    @beanstalk.put(msg1)
+    @beanstalk.use(tube2) # switch tubes to put messages on
+    msg2 = tube_message(tube2)
+    @beanstalk.put(msg2)
+
+    @beanstalk.ignore(tube1)
+    job = reserve(1)
+    assert_equal msg2, job.body, "body #{job.body.to_s} does not equal #{msg2}"
+    job.delete
+    job = reserve(1)
+    assert job.nil?
+
+    # clean up the last message from default
+    @beanstalk.watch(tube1)
+    job = reserve(1)
+    assert_equal msg1, job.body, "body #{job.body.to_s} does not equal #{msg1}"
+    job.delete
+  end
+
+
+end