rsched 0.1.0 → 0.2.0

data/lib/rsched/command/rsched.rb

@@ -1,284 +1,5 @@
-require 'thread'
-require 'time'
-
-module RSched
-
-
-class Lock
-  def initialize(hostname, timeout)
-  end
-
-  # acquired=token, locked=false, finished=nil
-  def aquire(ident, time)
-  end
-
-  def release(token)
-  end
-
-  def finish(token)
-  end
-
-  def delete_before(ident, time)
-  end
-end
-
-
-class DBLock < Lock
-  def initialize(hostname, timeout, uri, user, pass)
-    require 'dbi'
-    @hostname = hostname
-    @timeout = timeout
-    @db = DBI.connect(uri, user, pass)
-    init_db
-  end
-
-  def init_db
-    sql = ''
-    sql << 'CREATE TABLE IF NOT EXISTS rsched ('
-    sql << '  ident VARCHAR(256) NOT NULL,'
-    sql << '  time INT NOT NULL,'
-    sql << '  host VARCHAR(256),'
-    sql << '  timeout INT,'
-    sql << '  finish INT,'
-    sql << '  PRIMARY KEY (ident, time));'
-    @db.execute(sql)
-  end
-
-  def aquire(ident, time)
-    now = Time.now.to_i
-    if try_insert(ident, time, now) || try_update(ident, time, now)
-      return [ident, time]
-    elsif check_finished(ident, time)
-      return nil
-    else
-      return false
-    end
-  end
-
-  def release(token)
-    ident, time = *token
-    n = @db.do('UPDATE rsched SET timeout=? WHERE ident = ? AND time = ? AND host = ?;',
-           0, ident, time, @hostname)
-    return n > 0
-  end
-
-  def finish(token)
-    ident, time = *token
-    now = Time.now.to_i
-    n = @db.do('UPDATE rsched SET finish=? WHERE ident = ? AND time = ? AND host = ?;',
-           now, ident, time, @hostname)
-    return n > 0
-  end
-
-  def delete_before(ident, time)
-    @db.do('DELETE FROM rsched WHERE ident = ? AND time < ? AND finish IS NOT NULL;', ident, time)
-  end
-
-  private
-  def try_insert(ident, time, now)
-    n = @db.do('INSERT INTO rsched (ident, time, host, timeout) VALUES (?, ?, ?, ?);',
-           ident, time, @hostname, now+@timeout)
-    return n > 0
-  rescue # TODO unique error
-    return false
-  end
-
-  def try_update(ident, time, now)
-    n = @db.do('UPDATE rsched SET host=?, timeout=? WHERE ident = ? AND time = ? AND finish IS NULL AND (timeout < ? OR host = ?);',
-            @hostname, now+@timeout, ident, time, now, @hostname)
-    return n > 0
-  end
-
-  def check_finished(ident, time)
-    x = @db.select_one('SELECT finish FROM rsched WHERE ident = ? AND time = ? AND finish IS NOT NULL;',
-                ident, time)
-    return x != nil
-  end
-end
-
-
-class Engine
-  class Sched
-    def initialize(cron, action, sched_start, from=Time.now.to_i, to=Time.now.to_i)
-      @tab = CronSpec::CronSpecification.new(cron)
-      @action = action
-      @sched_start = sched_start
-      @queue = []
-      @last_time = from
-      sched(to)
-    end
-
-    attr_reader :queue, :action
-
-    def sched(now)
-      while @last_time <= now
-        t = Time.at(@last_time).utc
-        if @tab.is_specification_in_effect?(t)
-          time = create_time_key(t)
-          @queue << time if time >= @sched_start
-        end
-        @last_time += 60
-      end
-      @queue.uniq!
-    end
-
-    private
-    if Time.respond_to?(:strptime)
-      def create_time_key(t)
-        Time.strptime(t.strftime('%Y%m%d%H%M00UTC'), '%Y%m%d%H%M%S%Z').to_i
-      end
-    else
-      require 'date'
-      def create_time_key(t)
-        Time.parse(DateTime.strptime(t.strftime('%Y%m%d%H%M00UTC'), '%Y%m%d%H%M%S').to_s).to_i
-      end
-    end
-  end
-
-  def initialize(lock, conf)
-    require 'cron-spec'
-    @lock = lock
-    @resume = conf[:resume]
-    @delay = conf[:delay]
-    @interval = conf[:interval]
-    @delete = conf[:delete]
-    @sched_start = conf[:from] || 0
-    @finished = false
-    @ss = {}
-
-    @mutex = Mutex.new
-    @cond = ConditionVariable.new
-  end
-
-  # {cron => (ident,action)}
-  def set_sched(ident, action, cron)
-    now = Time.now.to_i
-    @ss[ident] = Sched.new(cron, action, @sched_start, now-@resume, now-@delay)
-  end
-
-  def run(run_proc)
-    until @finished
-      one = false
-
-      now = Time.now.to_i - @delay
-      @ss.each_pair {|ident,s|
-
-        s.sched(now)
-        s.queue.delete_if {|time|
-          next if @finished
-
-          x = @lock.aquire(ident, time)
-          case x
-          when nil
-            # already finished
-            true
-
-          when false
-            # not finished but already locked
-            false
-
-          else
-            one = true
-            if process(ident, time, s.action, run_proc)
-              # success
-              @lock.finish(x)
-              try_delete(ident)
-              true
-            else
-              # fail
-              @lock.release(x)
-              false
-            end
-          end
-        }
-
-        break if @finished
-      }
-
-      return if @finished
-
-      unless one
-        cond_wait(@interval)
-      end
-
-    end
-  end
-
-  def shutdown
-    @finished = true
-    @mutex.synchronize {
-      @cond.broadcast
-    }
-  end
-
-  private
-  if ConditionVariable.new.method(:wait).arity == 1
-    require 'timeout'
-    def cond_wait(sec)
-      @mutex.synchronize {
-        Timeout.timeout(sec) {
-          @cond.wait(@mutex)
-        }
-      }
-    rescue Timeout::Error
-    end
-  else
-    def cond_wait(sec)
-      @mutex.synchronize {
-        @cond.wait(@mutex, sec)
-      }
-    end
-  end
-
-  def process(ident, time, action, run_proc)
-    begin
-      run_proc.call(ident, time, action)
-      return true
-    rescue
-      puts "failed ident=#{ident} time=#{time}: #{$!}"
-      $!.backtrace.each {|bt|
-        puts "  #{bt}"
-      }
-      return false
-    end
-  end
-
-  def try_delete(ident)
-    @lock.delete_before(ident, Time.now.to_i-@delete)
-  end
-end
-
-
-class ExecRunner
-  def initialize(cmd)
-    @cmd = cmd + ' ' + ARGV.map {|a| Shellwords.escape(a) }.join(' ')
-    @iobuf = ''
-  end
-
-  def call(ident, time, action)
-    message = [ident, time, action].join("\t")
-    IO.popen(@cmd, "r+") {|io|
-      io.write(message) rescue nil
-      io.close_write
-      begin
-        while true
-          io.sysread(1024, @iobuf)
-          print @iobuf
-        end
-      rescue EOFError
-      end
-    }
-    if $?.to_i != 0
-      raise "Command failed"
-    end
-  end
-end
-
-
-end  # module RSched
-
-
 require 'optparse'
+require 'rsched/engine'
 
 op = OptionParser.new
 

data/lib/rsched/dblock.rb

@@ -0,0 +1,78 @@
+
+module RSched
+
+
+class DBLock < Lock
+  def initialize(hostname, timeout, uri, user, pass)
+    require 'dbi'
+    @hostname = hostname
+    @timeout = timeout
+    @db = DBI.connect(uri, user, pass)
+    init_db
+  end
+
+  def init_db
+    sql = ''
+    sql << 'CREATE TABLE IF NOT EXISTS rsched ('
+    sql << '  ident VARCHAR(256) NOT NULL,'
+    sql << '  time INT NOT NULL,'
+    sql << '  host VARCHAR(256),'
+    sql << '  timeout INT,'
+    sql << '  finish INT,'
+    sql << '  PRIMARY KEY (ident, time));'
+    @db.execute(sql)
+  end
+
+  def acquire(ident, time, now=Time.now.to_i)
+    if try_insert(ident, time, now) || try_update(ident, time, now)
+      return [ident, time]
+    elsif check_finished(ident, time)
+      return nil
+    else
+      return false
+    end
+  end
+
+  def release(token)
+    ident, time = *token
+    n = @db.do('UPDATE rsched SET timeout=? WHERE ident = ? AND time = ? AND host = ?;',
+           0, ident, time, @hostname)
+    return n > 0
+  end
+
+  def finish(token, now=Time.now.to_i)
+    ident, time = *token
+    n = @db.do('UPDATE rsched SET finish=? WHERE ident = ? AND time = ? AND host = ?;',
+           now, ident, time, @hostname)
+    return n > 0
+  end
+
+  def delete_before(ident, time)
+    @db.do('DELETE FROM rsched WHERE ident = ? AND time < ? AND finish IS NOT NULL;', ident, time)
+  end
+
+  private
+  def try_insert(ident, time, now)
+    n = @db.do('INSERT INTO rsched (ident, time, host, timeout) VALUES (?, ?, ?, ?);',
+           ident, time, @hostname, now+@timeout)
+    return n > 0
+  rescue # TODO unique error
+    return false
+  end
+
+  def try_update(ident, time, now)
+    n = @db.do('UPDATE rsched SET host=?, timeout=? WHERE ident = ? AND time = ? AND finish IS NULL AND (timeout < ? OR host = ?);',
+            @hostname, now+@timeout, ident, time, now, @hostname)
+    return n > 0
+  end
+
+  def check_finished(ident, time)
+    x = @db.select_one('SELECT finish FROM rsched WHERE ident = ? AND time = ? AND finish IS NOT NULL;',
+                ident, time)
+    return x != nil
+  end
+end
+
+
+end
+

data/lib/rsched/engine.rb

@@ -0,0 +1,186 @@
+require 'thread'
+require 'time'
+require 'rsched/lock'
+
+module RSched
+
+
+class Engine
+  class Sched
+    def initialize(cron, action, sched_start, from=Time.now.to_i, to=Time.now.to_i)
+      require 'cron-spec'
+      @tab = CronSpec::CronSpecification.new(cron)
+      @action = action
+      @sched_start = sched_start
+      @queue = []
+      @last_time = from
+      sched(to)
+    end
+
+    attr_reader :queue, :action
+
+    def sched(now)
+      while @last_time <= now
+        t = Time.at(@last_time).utc
+        if @tab.is_specification_in_effect?(t)
+          time = create_time_key(t)
+          @queue << time if time >= @sched_start
+        end
+        @last_time += 60
+      end
+      @queue.uniq!
+    end
+
+    private
+    if Time.respond_to?(:strptime)
+      def create_time_key(t)
+        Time.strptime(t.strftime('%Y%m%d%H%M00UTC'), '%Y%m%d%H%M%S%Z').to_i
+      end
+    else
+      require 'date'
+      def create_time_key(t)
+        Time.parse(DateTime.strptime(t.strftime('%Y%m%d%H%M00UTC'), '%Y%m%d%H%M%S').to_s).to_i
+      end
+    end
+  end
+
+  def initialize(lock, conf)
+    @lock = lock
+    @resume = conf[:resume]
+    @delay = conf[:delay]
+    @interval = conf[:interval]
+    @delete = conf[:delete]
+    @sched_start = conf[:from] || 0
+    @finished = false
+    @ss = {}
+
+    @mutex = Mutex.new
+    @cond = ConditionVariable.new
+  end
+
+  # {cron => (ident,action)}
+  def set_sched(ident, action, cron)
+    now = Time.now.to_i
+    @ss[ident] = Sched.new(cron, action, @sched_start, now-@resume, now-@delay)
+  end
+
+  def run(run_proc)
+    until @finished
+      one = false
+
+      now = Time.now.to_i - @delay
+      @ss.each_pair {|ident,s|
+
+        s.sched(now)
+        s.queue.delete_if {|time|
+          next if @finished
+
+          x = @lock.acquire(ident, time)
+          case x
+          when nil
+            # already finished
+            true
+
+          when false
+            # not finished but already locked
+            false
+
+          else
+            one = true
+            if process(ident, time, s.action, run_proc)
+              # success
+              @lock.finish(x)
+              try_delete(ident)
+              true
+            else
+              # fail
+              @lock.release(x)
+              false
+            end
+          end
+        }
+
+        break if @finished
+      }
+
+      return if @finished
+
+      unless one
+        cond_wait(@interval)
+      end
+
+    end
+  end
+
+  def shutdown
+    @finished = true
+    @mutex.synchronize {
+      @cond.broadcast
+    }
+  end
+
+  private
+  if ConditionVariable.new.method(:wait).arity == 1
+    require 'timeout'
+    def cond_wait(sec)
+      @mutex.synchronize {
+        Timeout.timeout(sec) {
+          @cond.wait(@mutex)
+        }
+      }
+    rescue Timeout::Error
+    end
+  else
+    def cond_wait(sec)
+      @mutex.synchronize {
+        @cond.wait(@mutex, sec)
+      }
+    end
+  end
+
+  def process(ident, time, action, run_proc)
+    begin
+      run_proc.call(ident, time, action)
+      return true
+    rescue
+      puts "failed ident=#{ident} time=#{time}: #{$!}"
+      $!.backtrace.each {|bt|
+        puts "  #{bt}"
+      }
+      return false
+    end
+  end
+
+  def try_delete(ident)
+    @lock.delete_before(ident, Time.now.to_i-@delete)
+  end
+end
+
+
+class ExecRunner
+  def initialize(cmd)
+    @cmd = cmd + ' ' + ARGV.map {|a| Shellwords.escape(a) }.join(' ')
+    @iobuf = ''
+  end
+
+  def call(ident, time, action)
+    message = [ident, time, action].join("\t")
+    IO.popen(@cmd, "r+") {|io|
+      io.write(message) rescue nil
+      io.close_write
+      begin
+        while true
+          io.sysread(1024, @iobuf)
+          print @iobuf
+        end
+      rescue EOFError
+      end
+    }
+    if $?.to_i != 0
+      raise "Command failed"
+    end
+  end
+end
+
+
+end  # module RSched

data/lib/rsched/lock.rb

@@ -0,0 +1,27 @@
+
+module RSched
+
+
+class Lock
+  def initialize(hostname, timeout)
+  end
+
+  # acquired=token, locked=false, finished=nil
+  def acquire(ident, time)
+  end
+
+  def release(token)
+  end
+
+  def finish(token)
+  end
+
+  def delete_before(ident, time)
+  end
+end
+
+
+end
+
+require 'rsched/dblock'
+

data/lib/rsched/version.rb

@@ -0,0 +1,5 @@
+module RSched
+
+VERSION = '0.2.0'
+
+end

data/test/cat.sh

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

data/test/dblock_test.rb

@@ -0,0 +1,154 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class DBLockTest < Test::Unit::TestCase
+  TIMEOUT = 10
+  DB_PATH = File.dirname(__FILE__)+'/test.db'
+  DB_URI = "DBI:SQLite3:#{DB_PATH}"
+
+  def clean
+    FileUtils.rm_f DB_PATH
+  end
+
+  def test1_db
+    RSched::DBLock.new('test1', TIMEOUT, DB_URI, '', '')
+  end
+
+  def test2_db
+    RSched::DBLock.new('test2', TIMEOUT, DB_URI, '', '')
+  end
+
+  it 'acquire' do
+    clean
+
+    now = Time.now.to_i
+    time = Time.now.to_i / 60 * 60
+
+    db1 = test1_db
+    db2 = test2_db
+
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # different host can't lock
+    token = db2.acquire('ident1', time, now)
+    assert_equal false, token
+
+    # same host can relock
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # different identifier
+    token = db2.acquire('ident2', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # different time
+    token = db2.acquire('ident1', time+60, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+  end
+
+  it 'release' do
+    clean
+
+    now = Time.now.to_i
+    time = Time.now.to_i / 60 * 60
+
+    db1 = test1_db
+    db2 = test2_db
+
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    db1.release(token)
+
+    # released
+    token = db2.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+  end
+
+  it 'finish' do
+    clean
+
+    now = Time.now.to_i
+    time = Time.now.to_i / 60 * 60
+
+    db1 = test1_db
+    db2 = test2_db
+
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    db1.finish(token, now)
+
+    # finished
+    token_ = db1.acquire('ident1', time, now)
+    assert_equal nil, token_
+
+    # finished
+    token_ = db2.acquire('ident1', time, now)
+    assert_equal nil, token_
+  end
+
+  it 'timeout' do
+    clean
+
+    now = Time.now.to_i
+    time = Time.now.to_i / 60 * 60
+
+    db1 = test1_db
+    db2 = test2_db
+
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # not timed out
+    token_ = db2.acquire('ident1', time, now+TIMEOUT)
+    assert_equal false, token_
+
+    # timed out
+    token = db2.acquire('ident1', time, now+TIMEOUT+1)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # taken
+    token = db1.acquire('ident1', time, now+TIMEOUT+1)
+    assert_equal false, token
+  end
+
+  it 'extend' do
+    clean
+
+    now = Time.now.to_i
+    time = Time.now.to_i / 60 * 60
+
+    db1 = test1_db
+    db2 = test2_db
+
+    token = db1.acquire('ident1', time, now)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # same host can relock
+    # + extend timeout
+    token = db1.acquire('ident1', time, now+TIMEOUT)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+
+    # timeout is extended
+    token_ = db2.acquire('ident1', time, now+TIMEOUT+1)
+    assert_equal false, token_
+
+    # extended timeout is expired
+    token = db2.acquire('ident1', time, now+TIMEOUT*2+1)
+    assert_not_equal nil, token
+    assert_not_equal false, token
+  end
+end
+

data/test/exec_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class ExecTest < Test::Unit::TestCase
+  it 'success' do
+    success_sh  = File.expand_path File.dirname(__FILE__)+"/success.sh"
+    e = RSched::ExecRunner.new(success_sh)
+
+    ident = 'ident'
+    time = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    action = 'act'
+
+    assert_nothing_raised do
+      e.call(ident, time, action)
+    end
+  end
+
+  it 'fail' do
+    fail_sh  = File.expand_path File.dirname(__FILE__)+"/fail.sh"
+    e = RSched::ExecRunner.new(fail_sh)
+
+    ident = 'ident'
+    time = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    action = 'act'
+
+    assert_raise(RuntimeError) do
+      e.call(ident, time, action)
+    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"
+    e = RSched::ExecRunner.new("#{cat_sh} #{out_tmp}")
+
+    ident = 'ident'
+    time = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    action = 'act'
+
+    e.call(ident, time, action)
+
+    assert_equal [ident, time, action].join("\t"), File.read(out_tmp)
+  end
+
+  it 'huge' do
+    huge_sh  = File.expand_path File.dirname(__FILE__)+"/huge.sh"
+    e = RSched::ExecRunner.new("#{huge_sh}")
+
+    ident = 'ident'
+    time = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    action = 'act'
+
+    e.call(ident, time, action)
+
+    # should finish
+  end
+end
+

data/test/fail.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exit 1

data/test/huge.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+dd if=/dev/zero bs=1024 count=1024

data/test/sched_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+class SchedTest < Test::Unit::TestCase
+  MINUTE = 60
+  HOUR = 60*60
+  DAY = 60*60*24
+
+  it 'sched minutes' do
+    now = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    sched_start = now
+
+    sched = RSched::Engine::Sched.new("* * * * *", "act", sched_start, now, now)
+    assert_equal [now], sched.queue
+
+    sched = RSched::Engine::Sched.new("* * * * *", "act", sched_start, now, now+MINUTE*2)
+    assert_equal [now, now+MINUTE, now+MINUTE*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("*/2 * * * *", "act", sched_start, now, now+MINUTE*2)
+    assert_equal [now, now+MINUTE*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("0,1,3 * * * *", "act", sched_start, now, now+MINUTE*4)
+    assert_equal [now, now+MINUTE, now+MINUTE*3], sched.queue
+  end
+
+  it 'sched hours' do
+    now = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    sched_start = now
+
+    sched = RSched::Engine::Sched.new("0 * * * *", "act", sched_start, now, now)
+    assert_equal [now], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 * * * *", "act", sched_start, now, now+HOUR*2)
+    assert_equal [now, now+HOUR, now+HOUR*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 */2 * * *", "act", sched_start, now, now+HOUR*2)
+    assert_equal [now, now+HOUR*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 0,1,3 * * *", "act", sched_start, now, now+HOUR*4)
+    assert_equal [now, now+HOUR, now+HOUR*3], sched.queue
+  end
+
+  it 'sched hours' do
+    now = Time.parse("2010-02-02 00:00:00 UTC").to_i
+    sched_start = now
+
+    sched = RSched::Engine::Sched.new("0 0 * * *", "act", sched_start, now, now)
+    assert_equal [now], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 0 * * *", "act", sched_start, now, now+DAY*2)
+    assert_equal [now, now+DAY, now+DAY*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 0 */2 * *", "act", sched_start, now, now+DAY*2)
+    assert_equal [now, now+DAY*2], sched.queue
+
+    sched = RSched::Engine::Sched.new("0 0 2,3,5 * *", "act", sched_start, now, now+DAY*4)
+    assert_equal [now, now+DAY, now+DAY*3], sched.queue
+  end
+end
+

data/test/success.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exit 0

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+$LOAD_PATH << File.dirname(__FILE__)+"/../lib"
+require 'rsched/engine'
+require 'fileutils'
+
+class Test::Unit::TestCase
+  #class << self
+  #  alias_method :it, :test
+  #end
+	def self.it(name, &block)
+		define_method("test_#{name}", &block)
+	end
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rsched
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Sadayuki Furuhashi
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-11 00:00:00 +09:00
+date: 2011-07-12 00:00:00 +09:00
 default_executable: rsched
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,7 +61,19 @@ extra_rdoc_files:
 files: 
 - bin/rsched
 - lib/rsched/command/rsched.rb
+- lib/rsched/dblock.rb
+- lib/rsched/engine.rb
+- lib/rsched/lock.rb
+- lib/rsched/version.rb
+- test/dblock_test.rb
+- test/exec_test.rb
+- test/sched_test.rb
+- test/test_helper.rb
 - README.rdoc
+- test/cat.sh
+- test/fail.sh
+- test/huge.sh
+- test/success.sh
 has_rdoc: true
 homepage: 
 licenses: []
@@ -96,5 +108,12 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Generic Reliable Scheduler
-test_files: []
-
+test_files: 
+- test/dblock_test.rb
+- test/exec_test.rb
+- test/sched_test.rb
+- test/test_helper.rb
+- test/cat.sh
+- test/fail.sh
+- test/huge.sh
+- test/success.sh