perfectqueue 0.7.0

data/lib/perfectqueue/version.rb

@@ -0,0 +1,5 @@
+module PerfectQueue
+
+VERSION = '0.7.0'
+
+end

data/lib/perfectqueue/worker.rb

@@ -0,0 +1,211 @@
+
+module PerfectQueue
+
+
+class MonitorThread
+  def initialize(engine, conf)
+    @engine = engine
+    @log = @engine.log
+    @backend = engine.backend
+
+    @timeout = conf[:timeout] || 600
+    @heartbeat_interval = conf[:heartbeat_interval] || @timeout*3/4
+    @kill_timeout = conf[:kill_timeout] || @timeout*10
+    @kill_interval = conf[:kill_interval] || 60
+    @retry_wait = conf[:retry_wait] || nil
+
+    @token = nil
+    @heartbeat_time = nil
+    @kill_time = nil
+    @kill_proc = nil
+    @canceled = false
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+  end
+
+  def start
+    @log.debug "running worker."
+    @thread = Thread.new(&method(:run))
+  end
+
+  def run
+    until @engine.finished?
+      @mutex.synchronize {
+        while true
+          return if @engine.finished?
+          break if @token
+          @cond.wait(@mutex)
+        end
+      }
+      while true
+        sleep 1
+        @mutex.synchronize {
+          return if @engine.finished?
+          break unless @token
+          now = Time.now.to_i
+          try_extend(now)
+          try_kill(now)
+        }
+      end
+    end
+  rescue
+    @engine.stop($!)
+  end
+
+  def try_extend(now)
+    if now >= @heartbeat_time && !@canceled
+      @log.debug "extending timeout=#{now+@timeout} id=#{@task.id}"
+      begin
+        @backend.update(@token, now+@timeout)
+      rescue CanceledError
+        @log.info "task id=#{@task.id} is canceled."
+        @canceled = true
+        @kill_time = now
+      end
+      @heartbeat_time = now + @heartbeat_interval
+    end
+  end
+
+  def try_kill(now)
+    if now >= @kill_time
+      kill!
+      @kill_time = now + @kill_interval
+    end
+  end
+
+  def kill!
+    if @kill_proc
+      @log.info "killing #{@task.id}..."
+      @kill_proc.call rescue nil
+    end
+  end
+
+  def stop
+    @mutex.synchronize {
+      @cond.broadcast
+    }
+  end
+
+  def shutdown
+    @thread.join
+  end
+
+  def set(token)
+    @mutex.synchronize {
+      now = Time.now.to_i
+      @token = token
+      @heartbeat_time = now + @heartbeat_interval
+      @kill_time = now + @kill_timeout
+      @kill_proc = nil
+      @canceled = false
+      @cond.broadcast
+    }
+  end
+
+  def set_kill_proc(kill_proc)
+    @kill_proc = kill_proc
+  end
+
+  def reset(success)
+    @mutex.synchronize {
+      if success
+        @backend.finish(@token)
+      elsif @retry_wait && !@canceled
+        begin
+          @backend.update(@token, Time.now.to_i+@retry_wait)
+        rescue
+          # ignore CanceledError
+        end
+      end
+      @token = nil
+    }
+  end
+end
+
+
+class Worker
+  def initialize(engine, conf)
+    @engine = engine
+    @log = @engine.log
+
+    @run_class = conf[:run_class]
+    @monitor = MonitorThread.new(engine, conf)
+
+    @token = nil
+    @task = nil
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+  end
+
+  def start
+    @thread = Thread.new(&method(:run))
+    @monitor.start
+  end
+
+  def run
+    while true
+      @mutex.synchronize {
+        while true
+          return if @engine.finished?
+          break if @token
+          @cond.wait(@mutex)
+        end
+      }
+      begin
+        process(@token, @task)
+      ensure
+        @token = nil
+        @engine.release_worker(self)
+      end
+    end
+  rescue
+    @engine.stop($!)
+  end
+
+  def process(token, task)
+    @log.info "processing task id=#{task.id}"
+
+    @monitor.set(token)
+    success = false
+    begin
+      run = @run_class.new(task)
+
+      if run.respond_to?(:kill)
+        @monitor.set_kill_proc run.method(:kill)
+      end
+
+      run.run
+
+      @log.info "finished id=#{task.id}"
+      success = true
+
+    rescue
+      @log.info "failed id=#{task.id}: #{$!}"
+
+    ensure
+      @monitor.reset(success)
+    end
+  end
+
+  def stop
+    submit(nil, nil)
+    @monitor.stop
+  end
+
+  def shutdown
+    @monitor.shutdown
+    @thread.join
+  end
+
+  def submit(token, task)
+    @mutex.synchronize {
+      @token = token
+      @task = task
+      @cond.broadcast
+    }
+  end
+end
+
+
+end
+

data/test/backend_test.rb

@@ -0,0 +1,217 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class BackendTest < Test::Unit::TestCase
+  TIMEOUT = 10
+  DB_PATH = File.dirname(__FILE__)+'/test.db'
+  DB_URI = "sqlite://#{DB_PATH}"
+
+  def clean_backend
+    @key_prefix = "test-#{"%08x"%rand(2**32)}-"
+    db = open_backend
+    db.list {|id,created_at,data,timeout|
+      db.cancel(id)
+    }
+    FileUtils.rm_f DB_PATH
+  end
+
+  def open_backend
+    #PerfectQueue::SimpleDBBackend.new(ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], 'perfectqueue-test-1').use_consistent_read
+    PerfectQueue::RDBBackend.new(DB_URI, "perfectdb_test")
+  end
+
+  it 'acquire' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+    db3 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db2.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+
+    token_, task_ = db3.acquire(time+TIMEOUT)
+    assert_equal nil, token_
+  end
+
+  it 'finish' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db1.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+
+    ok = db1.finish(token)
+    assert_equal true, ok
+
+    token_, task_ = db2.acquire(time+TIMEOUT)
+    assert_equal nil, token_
+
+    ok = db1.finish(token)
+    assert_equal false, ok
+  end
+
+  it 'canceled' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db1.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+
+    ok = db1.cancel(task.id)
+    assert_equal true, ok
+
+    token_, task_ = db2.acquire(time+TIMEOUT)
+    assert_equal nil, token_
+
+    assert_raise(PerfectQueue::CanceledError) do
+      db1.update(token, time+TIMEOUT)
+    end
+
+    ok = db1.cancel(task.id)
+    assert_equal false, ok
+  end
+
+  it 'order' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+    db3 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    ok = db1.submit(@key_prefix+'test2', 'data2', time-1)
+    assert_equal true, ok
+
+    ok = db1.submit(@key_prefix+'test3', 'data3', time+1)
+    assert_equal true, ok
+
+    token, task = db2.acquire(time+TIMEOUT, time+1)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test2', task.id
+    assert_equal time-1, task.created_at
+    assert_equal 'data2', task.data
+
+    token, task = db2.acquire(time+TIMEOUT, time+1)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+
+    token, task = db2.acquire(time+TIMEOUT, time+1)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test3', task.id
+    assert_equal time+1, task.created_at
+    assert_equal 'data3', task.data
+  end
+
+  it 'timeout' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db1.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+
+    token, task = db2.acquire(time+TIMEOUT*2, time+TIMEOUT)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+  end
+
+  it 'extend' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db1.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+
+    assert_nothing_raised do
+      db1.update(token, time+TIMEOUT)
+    end
+
+    token_, task_ = db2.acquire(time+TIMEOUT, time)
+    assert_equal nil, token_
+
+    token, task = db2.acquire(time+TIMEOUT*2, time+TIMEOUT)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+  end
+
+  it 'release' do
+    clean_backend
+
+    db1 = open_backend
+    db2 = open_backend
+
+    time = Time.now.to_i
+
+    ok = db1.submit(@key_prefix+'test1', 'data1', time)
+    assert_equal true, ok
+
+    token, task = db1.acquire(time+TIMEOUT)
+    assert_not_equal nil, task
+
+    assert_nothing_raised do
+      db1.update(token, time+TIMEOUT)
+    end
+
+    token_, task_ = db2.acquire(time+TIMEOUT, time)
+    assert_equal nil, token_
+
+    assert_nothing_raised do
+      db1.update(token, time)
+    end
+
+    token, task = db2.acquire(time+TIMEOUT, time)
+    assert_not_equal nil, task
+    assert_equal @key_prefix+'test1', task.id
+    assert_equal time, task.created_at
+    assert_equal 'data1', task.data
+  end
+end
+

data/test/cat.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+cat > "$1"

data/test/echo.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+out="$1"
+shift
+echo "$@" > "$out"

data/test/exec_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class ExecTest < Test::Unit::TestCase
+  it 'success' do
+    success_sh  = File.expand_path File.dirname(__FILE__)+"/success.sh"
+
+    task = PerfectQueue::Task.new('test1', Time.now.to_i, 'data1')
+    e = PerfectQueue::ExecRunner.new(success_sh, task)
+
+    assert_nothing_raised do
+      e.run
+    end
+  end
+
+  it 'fail' do
+    fail_sh  = File.expand_path File.dirname(__FILE__)+"/fail.sh"
+
+    task = PerfectQueue::Task.new('test1', Time.now.to_i, 'data1')
+    e = PerfectQueue::ExecRunner.new(fail_sh, task)
+
+    assert_raise(RuntimeError) do
+      e.run
+    end
+  end
+
+  it 'stdin' do
+    cat_sh  = File.expand_path File.dirname(__FILE__)+"/cat.sh"
+    out_tmp = File.expand_path File.dirname(__FILE__)+"/cat.sh.tmp"
+
+    task = PerfectQueue::Task.new('test1', Time.now.to_i, 'data1')
+    e = PerfectQueue::ExecRunner.new("#{cat_sh} #{out_tmp}", task)
+
+    e.run
+
+    assert_equal 'data1', File.read(out_tmp)
+  end
+
+  it 'echo' do
+    echo_sh  = File.expand_path File.dirname(__FILE__)+"/echo.sh"
+    out_tmp = File.expand_path File.dirname(__FILE__)+"/echo.sh.tmp"
+
+    task = PerfectQueue::Task.new('test1', Time.now.to_i, 'data1')
+    e = PerfectQueue::ExecRunner.new("#{echo_sh} #{out_tmp}", task)
+
+    e.run
+
+    assert_equal "test1\n", File.read(out_tmp)
+  end
+
+  it 'huge' do
+    huge_sh  = File.expand_path File.dirname(__FILE__)+"/huge.sh"
+
+    task = PerfectQueue::Task.new('test1', Time.now.to_i, 'data1')
+    e = PerfectQueue::ExecRunner.new(huge_sh, task)
+
+    e.run
+
+    # should finish
+  end
+end
+