perfectsched 0.7.19 → 0.8.0

data/lib/perfectsched/backend/null.rb

@@ -1,45 +0,0 @@
-
-module PerfectSched
-
-
-class NullBackend < Backend
-  def list(&block)
-    nil
-  end
-
-  def acquire(timeout, now=Time.now.to_i)
-    nil
-  end
-
-  def finish(token, next_time, timeout)
-    true
-  end
-
-  def add_checked(id, cron, delay, data, next_time, timeout, timezone)
-    true
-  end
-
-  def delete(id)
-    true
-  end
-
-  def get(id)
-    nil
-  end
-
-  def modify_checked(id, cron, delay, data, timezone)
-    true
-  end
-
-  def modify_sched_checked(id, cron, delay)
-    true
-  end
-
-  def modify_data_checked(id, data)
-    true
-  end
-end
-
-
-end
-

data/lib/perfectsched/backend/rdb.rb

@@ -1,165 +0,0 @@
-
-module PerfectSched
-
-
-class RDBBackend < Backend
-  def initialize(uri, table, config={})
-    super()
-    require 'sequel'
-    require 'uri'
-    @uri = uri
-    @table = table
-
-    u = URI.parse(@uri)
-    options = {
-      max_connections: 1,
-      user: u.user,
-      password: u.password,
-      host: u.host,
-      port: u.port ? u.port.to_i : 3306
-    }
-    options[:sslca] = config[:sslca] if config[:sslca]
-    db_name = u.path.split('/')[1]
-    @db = Sequel.mysql2(db_name, options)
-
-    #init_db(@uri.split('//',2)[0])
-    connect {
-      # connection test
-    }
-  end
-
-  def create_tables
-    sql = ''
-    sql << "CREATE TABLE IF NOT EXISTS `#{@table}` ("
-    sql << "  id VARCHAR(256) NOT NULL,"
-    sql << "  timeout INT NOT NULL,"
-    sql << "  next_time INT NOT NULL,"
-    sql << "  cron VARCHAR(128) NOT NULL,"
-    sql << "  delay INT NOT NULL,"
-    sql << "  data BLOB NOT NULL,"
-    sql << "  timezone VARCHAR(256) NULL,"
-    sql << "  PRIMARY KEY (id)"
-    sql << ");"
-    # TODO index
-    connect {
-      @db.run sql
-    }
-  end
-
-  private
-  def connect(&block)
-    begin
-      block.call
-    ensure
-      @db.disconnect
-    end
-  end
-
-  public
-  def list(&block)
-    @db.fetch("SELECT id, timeout, next_time, cron, delay, data, timezone FROM `#{@table}` ORDER BY timeout ASC") {|row|
-      yield row[:id], row[:cron], row[:delay], row[:data], row[:next_time], row[:timeout], row[:timezone]
-    }
-  end
-
-  MAX_SELECT_ROW = 4
-
-  def acquire(timeout, now=Time.now.to_i)
-    connect {
-      while true
-        rows = 0
-        @db.fetch("SELECT id, timeout, next_time, cron, delay, data, timezone FROM `#{@table}` WHERE timeout <= ? ORDER BY timeout ASC LIMIT #{MAX_SELECT_ROW};", now) {|row|
-
-          n = @db["UPDATE `#{@table}` SET timeout=? WHERE id=? AND timeout=?;", timeout, row[:id], row[:timeout]].update
-          salt = timeout
-          if n > 0
-            return [row[:id],salt], Task.new(row[:id], row[:next_time], row[:cron], row[:delay], row[:data], row[:timezone])
-          end
-
-          rows += 1
-        }
-        if rows < MAX_SELECT_ROW
-          return nil
-        end
-      end
-    }
-  end
-
-  def finish(token, next_time, timeout)
-    connect {
-      id, salt = *token
-      n = @db["UPDATE `#{@table}` SET timeout=?, next_time=? WHERE id=? AND timeout=?;", timeout, next_time, id, salt].update
-      return n > 0
-    }
-  end
-
-  def add_checked(id, cron, delay, data, next_time, timeout, timezone)
-    connect {
-      begin
-        n = @db["INSERT INTO `#{@table}` (id, timeout, next_time, cron, delay, data, timezone) VALUES (?, ?, ?, ?, ?, ?, ?);", id, timeout, next_time, cron, delay, data, timezone].insert
-        return true
-      rescue Sequel::DatabaseError
-        return nil
-      end
-    }
-  end
-
-  def delete(id)
-    connect {
-      n = @db["DELETE FROM `#{@table}` WHERE id=?;", id].delete
-      return n > 0
-    }
-  end
-
-  def get(id)
-    connect {
-      @db.fetch("SELECT id, timeout, next_time, cron, delay, data, timezone FROM `#{@table}` WHERE id=?;", id) {|row|
-        return row[:cron], row[:delay], row[:data], row[:timezone], row[:next_time]
-      }
-      return nil
-    }
-  end
-  
-  # Overrides parent method in order to pass the calculated next run time into modify_checked
-  def modify(id, cron, delay, data, timezone)
-    cron = cron.strip
-    next_time = @croncalc.next_time(cron, Time.now.to_i/60*60, timezone)
-    modify_checked(id, cron, delay, data, timezone, next_time)
-    return next_time, next_time + delay
-  end
-
-  # Overrides parent method in order to pass the calculated next run time into modify_sched_checked
-  def modify_sched(id, cron, delay)
-    cron_, delay_, data_, timezone, next_time = get(id)
-    cron = cron.strip
-    next_time = @croncalc.next_time(cron, Time.now.to_i/60*60, timezone)
-    modify_sched_checked(id, cron, delay, next_time)
-    return next_time, next_time + delay
-  end
-
-  def modify_checked(id, cron, delay, data, timezone, next_time)
-    connect {
-      n = @db["UPDATE `#{@table}` SET cron=?, delay=?, data=?, timezone=?, next_time=?, timeout=? WHERE id=?;", cron, delay, data, timezone, next_time, next_time + delay, id].update
-      return n > 0
-    }
-  end
-
-  def modify_sched_checked(id, cron, delay, next_time)
-    connect {
-      n = @db["UPDATE `#{@table}` SET cron=?, delay=?, next_time=?, timeout=? WHERE id=?;", cron, delay, next_time, next_time + delay, id].update
-      return n > 0
-    }
-  end
-
-  def modify_data_checked(id, data)
-    connect {
-      n = @db["UPDATE `#{@table}` SET data=? WHERE id=?;", data, id].update
-      return n > 0
-    }
-  end
-
-end
-
-
-end
-

data/lib/perfectsched/backend/simpledb.rb

@@ -1,174 +0,0 @@
-
-module PerfectSched
-
-
-class SimpleDBBackend < Backend
-  def initialize(key_id, secret_key, domain)
-    super()
-    require 'aws-sdk'
-    @consistent_read = false
-
-    @db = AWS::SimpleDB.new(
-      :access_key_id => key_id,
-      :secret_access_key => secret_key)
-
-    @domain_name = domain
-    @domain = @db.domains[@domain_name]
-    unless @domain.exists?
-      @domain = @db.domains.create(@domain_name)
-    end
-  end
-
-  attr_accessor :consistent_read
-
-  def use_consistent_read(b=true)
-    @consistent_read = b
-    self
-  end
-
-  def list(&block)
-    rows = 0
-    @domain.items.select('timeout', 'next_time', 'cron', 'delay', 'data', 'timezone',
-                        :where => "timeout > '#{int_encode(0)}'",  # required by SimpleDB
-                        :order => [:timeout, :asc],
-                        :consistent_read => @consistent_read,
-                        :limit => MAX_SELECT_ROW) {|itemdata|
-      id = itemdata.name
-      attrs = itemdata.attributes
-
-      next_time = int_decode(attrs['next_time'].first)
-      cron = attrs['cron'].first
-      delay = int_decode(attrs['delay'].first)
-      data = attrs['data'].first
-      timezone = attrs['timezone'].first
-      timeout = int_decode(attrs['timeout'].first)
-
-      yield id, cron, delay, data, next_time, timeout, timezone
-    }
-  end
-
-  MAX_SELECT_ROW = 4
-
-  def acquire(timeout, now=Time.now.to_i)
-    while true
-      rows = 0
-        @domain.items.select('timeout', 'next_time', 'cron', 'delay', 'data', 'timezone',
-                          :where => "timeout <= '#{int_encode(now)}'",
-                          :order => [:timeout, :asc],
-                          :consistent_read => @consistent_read,
-                          :limit => MAX_SELECT_ROW) {|itemdata|
-        begin
-          id = itemdata.name
-          attrs = itemdata.attributes
-
-          @domain.items[id].attributes.replace('timeout'=>int_encode(timeout),
-              :if=>{'timeout'=>attrs['timeout'].first})
-
-          next_time = int_decode(attrs['next_time'].first)
-          cron = attrs['cron'].first
-          delay = int_decode(attrs['delay'].first)
-          data = attrs['data'].first
-          timezone = attrs['timezone'].first
-          salt = int_encode(timeout)
-
-          return [id,salt], Task.new(id, next_time, cron, delay, data, timezone)
-
-        rescue AWS::SimpleDB::Errors::ConditionalCheckFailed, AWS::SimpleDB::Errors::AttributeDoesNotExist
-        end
-
-        rows += 1
-      }
-      if rows < MAX_SELECT_ROW
-        return nil
-      end
-    end
-  end
-
-  def finish(token, next_time, timeout)
-    begin
-      id, salt = *token
-      @domain.items[id].attributes.replace('timeout'=>int_encode(timeout), 'next_time'=>int_encode(next_time),
-          :if=>{'timeout'=>salt})
-      return true
-    rescue AWS::SimpleDB::Errors::ConditionalCheckFailed, AWS::SimpleDB::Errors::AttributeDoesNotExist
-      return false
-    end
-  end
-
-  def add_checked(id, cron, delay, data, next_time, timeout, timezone)
-    begin
-      hash = {}
-      hash['timeout'] = int_encode(timeout)
-      hash['next_time'] = int_encode(next_time)
-      hash['cron'] = cron
-      hash['delay'] = int_encode(delay)
-      hash['data'] = data
-      hash['timezone'] = timezone if timezone
-      hash[:unless] = 'timeout'
-      @domain.items[id].attributes.replace()
-      return true
-    rescue AWS::SimpleDB::Errors::ConditionalCheckFailed, AWS::SimpleDB::Errors::ExistsAndExpectedValue
-      return nil
-    end
-  end
-
-  def delete(id)
-    # TODO return value
-    begin
-      @domain.items[id].delete
-      return true
-    rescue AWS::SimpleDB::Errors::ConditionalCheckFailed, AWS::SimpleDB::Errors::AttributeDoesNotExist
-      return false
-    end
-  end
-
-  def get(id)
-    attrs = @domain.items[id].data.attributes
-    cron = attrs['cron'].first
-    unless cron
-      return nil
-    end
-    delay = int_decode(attrs['delay'].first)
-    data = attrs['data'].first
-    timezone = attrs['timezone'].first
-    next_time = int_decode(attrs['next_time'].first)
-    return cron, delay, data, timezone, next_time
-  end
-
-  def modify_checked(id, cron, delay, data, timezone)
-    unless get(id)
-      return false
-    end
-    @domain.items[id].attributes.replace('cron'=>cron, 'delay'=>int_encode(delay), 'data'=>data, 'timezone'=>timezone)
-    return true
-  end
-
-  def modify_sched_checked(id, cron, delay)
-    unless get(id)
-      return false
-    end
-    @domain.items[id].attributes.replace('cron'=>cron, 'delay'=>int_encode(delay))
-    return true
-  end
-
-  def modify_data_checked(id, data)
-    unless get(id)
-      return false
-    end
-    @domain.items[id].attributes.replace('data'=>data)
-    return true
-  end
-
-  private
-  def int_encode(num)
-    "%08x" % num
-  end
-
-  def int_decode(str)
-    str.to_i(16)
-  end
-end
-
-
-end
-

data/lib/perfectsched/croncalc.rb

@@ -1,29 +0,0 @@
-
-module PerfectSched
-
-
-class CronCalc
-  def initialize
-    require 'cron-spec'
-    require 'tzinfo'
-    # TODO optimize
-  end
-
-  def next_time(cron, time, timezone)
-    tab = CronSpec::CronSpecification.new(cron)
-    tz = TZInfo::Timezone.get(timezone) if timezone
-    while true
-      time += 60
-      t = Time.at(time)
-      t = tz.utc_to_local(t.utc) if tz
-      if tab.is_specification_in_effect?(t)
-        return time
-      end
-      # FIXME break
-    end
-  end
-end
-
-
-end
-

data/test/backend_test.rb

@@ -1,217 +0,0 @@
-require File.dirname(__FILE__)+'/test_helper'
-
-class BackendTest < Test::Unit::TestCase
-  SCHED = 120
-  TIMEOUT = 60
-  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,cron,delay,data,next_time,timeout|
-      db.delete(id)
-    }
-    FileUtils.rm_f DB_PATH
-  end
-
-  def open_backend
-    #PerfectSched::SimpleDBBackend.new(ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'], 'perfectsched-test-1').use_consistent_read
-    db = PerfectSched::RDBBackend.new(DB_URI, "perfectdb_test")
-    db.create_tables
-    db
-  end
-
-  it 'acquire' do
-    clean_backend
-
-    db1 = open_backend
-    db2 = open_backend
-    db3 = open_backend
-
-    time = 0
-
-    ok = db1.add(@key_prefix+'test1', "* * * * *", 0, 'data1', time)
-    assert_equal true, ok
-
-    token, task = db2.acquire(180, 60)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal "* * * * *", task.cron
-    assert_equal 0, task.delay
-    assert_equal 'data1', task.data
-    assert_equal 60, task.time
-
-    token_, task_ = db3.acquire(180, 60)
-    assert_equal nil, token_
-
-    token_, task_ = db3.acquire(240, 120)
-    assert_equal nil, token_
-
-    ok = db2.finish(token, 120, 120)
-    assert_equal true, ok
-
-    token, task = db3.acquire(240, 120)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal "* * * * *", task.cron
-    assert_equal 0, task.delay
-    assert_equal 'data1', task.data
-    assert_equal 120, task.time
-  end
-
-  it 'timeout' do
-    clean_backend
-
-    db1 = open_backend
-    db2 = open_backend
-    db3 = open_backend
-
-    time = 0
-
-    ok = db1.add(@key_prefix+'test1', "* * * * *", 0, 'data1', time)
-    assert_equal true, ok
-
-    token, task = db2.acquire(180, 60)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal "* * * * *", task.cron
-    assert_equal 0, task.delay
-    assert_equal 'data1', task.data
-    assert_equal 60, task.time
-
-    token, task = db3.acquire(240, 180)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal "* * * * *", task.cron
-    assert_equal 0, task.delay
-    assert_equal 'data1', task.data
-    assert_equal 60, task.time
-  end
-
-  it 'delay' do
-    clean_backend
-
-    db1 = open_backend
-    db2 = open_backend
-    db3 = open_backend
-
-    time = 0
-
-    ok = db1.add(@key_prefix+'test1', "* * * * *", 30, 'data1', time)
-    assert_equal true, ok
-
-    token_, task_ = db2.acquire(180, 60)
-    assert_equal nil, token_
-
-    token, task = db2.acquire(210, 90)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal "* * * * *", task.cron
-    assert_equal 30, task.delay
-    assert_equal 'data1', task.data
-    assert_equal 60, task.time
-  end
-
-  it 'invalid format' do
-    clean_backend
-
-    db1 = open_backend
-
-    assert_raise(RuntimeError) do
-      db1.add('k', '???', 0, 'data1', 0)
-    end
-
-    assert_raise(RuntimeError) do
-      db1.add('k', '* * * * * *', 0, 'data1', 0)
-    end
-  end
-
-  it 'unique id' do
-    clean_backend
-
-    db1 = open_backend
-    time = 0
-    key = @key_prefix+'test1'
-
-    ok = db1.add(key, "* * * * *", 0, 'data1', time)
-    assert_equal true, ok
-
-    ok = db1.add(key, "* * * * *", 0, 'data1', time)
-    assert_not_equal true, ok
-
-    ok = db1.delete(key)
-    assert_equal true, ok
-
-    ok = db1.add(key, "* * * * *", 0, 'data1', time)
-    assert_equal true, ok
-  end
-
-  it 'modify' do
-    clean_backend
-
-    db1 = open_backend
-    time = 0
-    key = @key_prefix+'test1'
-
-    ok = db1.add(key, "* * * * *", 0, 'data1', time)
-    assert_equal true, ok
-
-    cron, delay, data, timezone, next_time = db1.get(key)
-    assert_equal "* * * * *", cron
-    assert_equal 0, delay
-    assert_equal 'data1', data
-    assert_equal time+60, next_time
-
-    ok = db1.modify_sched(key, "* * * * 1", 10)
-    assert_equal true, ok
-
-    cron, delay, data, timezone, next_time = db1.get(key)
-    assert_equal "* * * * 1", cron
-    assert_equal 10, delay
-    assert_equal 'data1', data
-    assert_equal time+60, next_time
-
-    ok = db1.modify_data(key, "data2")
-    assert_equal true, ok
-
-    cron, delay, data, timezone, next_time = db1.get(key)
-    assert_equal "* * * * 1", cron
-    assert_equal 10, delay
-    assert_equal 'data2', data
-    assert_equal time+60, next_time
-
-    ok = db1.modify(key, "* * * * 2", 20, "data3", nil)
-    assert_equal true, ok
-
-    cron, delay, data, timezone, next_time = db1.get(key)
-    assert_equal "* * * * 2", cron
-    assert_equal 20, delay
-    assert_equal 'data3', data
-    assert_equal time+60, next_time
-  end
-
-  it 'timezone' do
-    clean_backend
-
-    db1 = open_backend
-    time = 1323820800  # 2011-12-14 00:00:00 UTC
-
-    ok = db1.add(@key_prefix+'test1', "0 0 * * *", 0, '', time-60, 'UTC')
-    assert_equal true, ok
-
-    ok = db1.add(@key_prefix+'test2', "0 0 * * *", 0, '', time-60, 'Asia/Tokyo')
-    assert_equal true, ok
-
-    token, task = db1.acquire(time+86400, time)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test1', task.id
-    assert_equal time, task.time
-
-    token, task = db1.acquire(time+54000+86400, time+54000)
-    assert_not_equal nil, task
-    assert_equal @key_prefix+'test2', task.id
-    assert_equal time+54000, task.time
-  end
-end
-