perfectsched 0.8.10 → 0.8.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 759e18c224ac736b6883bde03b5cd95928e7e50f
-  data.tar.gz: 08c3aa5151589a8b485fbe252e291162f515f447
+  metadata.gz: 6a1e556c19cb6846d4efa60879d267a272fd9d8c
+  data.tar.gz: a8c46704005fd12df81826d6759ab0a9934e8a8f
 SHA512:
-  metadata.gz: d5d3af6f43295e37bc3932ee3367880f77c9489bd96e2aeae841574dd4e3581659a333ca08f2e8d98d8a51f07d17e5f452352b0512713a6483a131236f5a3537
-  data.tar.gz: c85f86c27798a539c96d476df07893a63ec137d56ae9f1e383ccc426a5f3ba1fdab9fd6d693a744a781132688549b1f3b57989ac7e90efea8c85458a1f35d1fe
+  metadata.gz: 2f4ca879b0acb729876fddfaa0712694701c65208039e48e93ee0853d7b141e80d16f59bb2c894e38864fa737bfb86c9cdbfa72737e95b22d7b1e009fa570a3f
+  data.tar.gz: d99b81c74ccd32504d4d334259491eabdfb6fdf9db790ee6c6ac0120c9c9678ff678cd256364a7694c84ec74697195f7b74d4e89225fe209f8cd8e114e7250bc

data/.travis.yml

@@ -1,8 +1,15 @@
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.6
-  - 2.2.2
+  - 2.2.5
+  - 2.3.1
   - ruby-head
 
 script: "bundle exec rake spec"
+
+sudo: false
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+
+notifications:
+  webhooks: http://td-beda.herokuapp.com/travisci_callback

data/ChangeLog

@@ -1,3 +1,9 @@
+== 2016-09-18 version 0.8.11
+
+* allow perfectqueue v0.9.x
+* drop ruby 2.0 support
+* use chrono instead of cron-spec
+* explicitly specify development dependency rspec, simplecov and mysql
 
 == 2015-06-29 version 0.8.10
 

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'coveralls', require: false

data/README.md

@@ -1,6 +1,7 @@
 # PerfectSched
 
 [![Build Status](https://travis-ci.org/treasure-data/perfectsched.svg?branch=master)](https://travis-ci.org/treasure-data/perfectsched)
+[![Coverage Status](https://coveralls.io/repos/treasure-data/perfectsched/badge.svg?branch=master&service=github)](https://coveralls.io/github/treasure-data/perfectsched?branch=master)
 
 PerfectSched is a highly available distributed cron built on top of RDBMS.
 
@@ -85,7 +86,7 @@ PerfectSched.open(config) {|sc|
     :next_time => Time.parse('2013-01-01 00:00:00 +0900').to_i,
     :data => data,
   }
-  sc.submit("sched-id", "type1", options)
+  sc.add("sched-id", "type1", options)
 }
 ```
 

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.3.1

data/lib/perfectsched.rb

@@ -52,7 +52,7 @@ module PerfectSched
     require File.expand_path(v, File.dirname(__FILE__))
   }
 
-  require 'cron-spec'
+  require 'chrono'
   require 'tzinfo'
 
   def self.open(config, &block)
@@ -71,28 +71,9 @@ module PerfectSched
   end
 
   def self.cron_time(cron, timestamp, timezone)
-    begin
-      tab = CronSpec::CronSpecification.new(cron)
-    rescue
-      raise ArgumentError, "invalid cron format: #{$!}: #{cron.inspect}"
-    end
-
-    begin
-      tz = TZInfo::Timezone.get(timezone) if timezone
-    rescue
-      raise ArgumentError, "unknown timezone: #{$!}: #{timezone.inspect}"
-    end
-
-    ts = (timestamp + 59) / 60 * 60
-    while true
-      t = Time.at(ts).utc
-      t = tz.utc_to_local(t) if tz
-      if tab.is_specification_in_effect?(t)
-        return ts
-      end
-      ts += 60
-      # FIXME break
-    end
+    ts = timestamp - 1 # compatibility
+    t = Time.find_zone!(timezone || 'UTC'.freeze).at(ts)
+    Chrono::NextTime.new(now: t, source: cron).to_time.to_i
   end
 
   def self.next_time(cron, before_timestamp, timezone)

data/lib/perfectsched/application/decider.rb

@@ -40,7 +40,7 @@ module PerfectSched
         begin
           m = method(type)
         rescue NameError
-          raise UndefinedDecisionError, "Undefined decision #{type} options=#{opt.inspect}"
+          raise UndefinedDecisionError, "Undefined decision #{type} options=#{opts.inspect}"
         end
         m.call(opts)
       end

data/lib/perfectsched/backend/rdb_compat.rb

@@ -20,6 +20,7 @@ module PerfectSched
   module Backend
     class RDBCompatBackend
       include BackendHelper
+      MAX_RETRY = 10
 
       class Token < Struct.new(:row_id, :scheduled_time, :cron, :delay, :timezone)
       end
@@ -76,13 +77,13 @@ module PerfectSched
       def init_database(options)
         sql = %[
           CREATE TABLE IF NOT EXISTS `#{@table}` (
-            id VARCHAR(256) NOT NULL,
+            id VARCHAR(255) NOT NULL,
             timeout INT NOT NULL,
             next_time INT NOT NULL,
             cron VARCHAR(128) NOT NULL,
             delay INT NOT NULL,
-            data BLOB NOT NULL,
-            timezone VARCHAR(256) NULL,
+            data LONGBLOB NOT NULL,
+            timezone VARCHAR(255) NULL,
             PRIMARY KEY (id)
           );]
         connect {
@@ -97,7 +98,7 @@ module PerfectSched
             raise NotFoundError, "schedule key=#{key} does not exist"
           end
           attributes = create_attributes(row)
-          return ScheduleMetadata.new(@client, key, attributes)
+          return ScheduleWithMetadata.new(@client, key, attributes)
         }
       end
 

data/lib/perfectsched/schedule_metadata.rb

@@ -57,24 +57,4 @@ module PerfectSched
       @attributes[:message]
     end
   end
-
-  class ScheduleMetadata
-    include Model
-
-    def initialize(client, key, attributes)
-      super(client)
-      @key = key
-    end
-
-    def schedule
-      Schedule.new(@client, @key)
-    end
-
-    def inspect
-      "#<#{self.class} @key=#{@key.inspect} @attributes=#{@attributes.inspect}>"
-    end
-
-    include ScheduleMetadataAccessors
-  end
-
 end

data/lib/perfectsched/version.rb

@@ -1,3 +1,3 @@
 module PerfectSched
-  VERSION = "0.8.10"
+  VERSION = "0.8.11"
 end

data/lib/perfectsched/worker.rb

@@ -88,10 +88,7 @@ module PerfectSched
       begin
         return if @replaced_pid
         stop
-        @replaced_pid = Process.fork do
-          exec(*command)
-          exit!(127)
-        end
+        @replaced_pid = Process.spawn(*command)
       rescue
         @log.error "failed to replace: #{$!}"
         $!.backtrace.each {|bt| @log.warn "\t#{bt}" }

data/perfectsched.gemspec

@@ -16,12 +16,14 @@ Gem::Specification.new do |gem|
   gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.require_paths = ['lib']
 
-  gem.add_dependency "cron-spec", [">= 0.1.2", "<= 0.1.2"]
+  gem.required_ruby_version = '>= 2.1'
+  gem.add_dependency "chrono", "~> 0.3.0"
   gem.add_dependency "sequel", "~> 3.48.0"
   gem.add_dependency "tzinfo", "~> 1.1"
-  gem.add_dependency "perfectqueue", "~> 0.8.41"
+  gem.add_dependency "perfectqueue", "~>0.9", ">= 0.8.41"
   gem.add_development_dependency "rake", "~> 0.9.2"
-  gem.add_development_dependency "rspec", "~> 2.10.0"
-  gem.add_development_dependency "simplecov", "~> 0.5.4"
+  gem.add_development_dependency "rspec", "~> 3.4.0"
+  gem.add_development_dependency "simplecov", "~> 0.10.0"
   gem.add_development_dependency "sqlite3", "~> 1.3.3"
+  gem.add_development_dependency "mysql2", "~> 0.3.20"
 end

data/spec/application/base_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe PerfectSched::Application::Base do
+  describe '.decider=' do
+    it 'defines .decider which returns the decider' do
+      decider_klass = double('decider_klass')
+      klass = PerfectSched::Application::Base
+      allow(klass).to receive(:decider).and_call_original
+      allow(klass).to receive(:decider=).with(decider_klass).and_call_original
+      expect(klass.decider = decider_klass).to eq(decider_klass)
+      expect(klass.decider).to eq(decider_klass)
+    end
+  end
+
+  describe '.decider' do
+    it 'returns DefaultDecider' do
+      expect(PerfectSched::Application::Base.decider).to eq(PerfectSched::Application::DefaultDecider)
+    end
+  end
+
+  describe '#new' do
+    let (:task){ double('task') }
+    let (:base) { PerfectSched::Application::Base.new(task) }
+    it 'calls super and set decider'do
+      expect(base).to be_an_instance_of(PerfectSched::Application::Base)
+      expect(base.instance_variable_get(:@task)).to eq(task)
+      expect(base.instance_variable_get(:@decider)).to be_an_instance_of(Application::DefaultDecider)
+    end
+  end
+
+  describe '#run' do
+    let (:base) { PerfectSched::Application::Base.new(double('task')) }
+    it 'returns nil if before_perform returns false' do
+      allow(base).to receive(:before_perform).and_return(false)
+      expect(base.run).to be_nil
+    end
+    it 'returns nil' do
+      expect(base).to receive(:before_perform).exactly(:once).and_call_original
+      expect(base).to receive(:perform).exactly(:once).and_return(nil)
+      expect(base).to receive(:after_perform).exactly(:once).and_call_original
+      expect(base.run).to be_nil
+    end
+    it 'calls unexpected_error_raised on error' do
+      allow(base).to receive(:before_perform).exactly(:once).and_call_original
+      allow(base).to receive(:perform).exactly(:once) { raise }
+      allow(base).to receive(:decide!).with(:unexpected_error_raised, error: kind_of(Exception)).exactly(:once)
+      expect(base.run).to be_nil
+    end
+  end
+
+  describe '#before_perform' do
+    let (:base) { PerfectSched::Application::Base.new(double('task')) }
+    it 'returns true' do
+      expect(base.before_perform).to be true
+    end
+  end
+
+  describe '#after_perform' do
+    let (:base) { PerfectSched::Application::Base.new(double('task')) }
+    it 'returns nil' do
+      expect(base.after_perform).to be_nil
+    end
+  end
+
+  describe '#decide!' do
+    let (:base) do
+      decider = double('decider')
+      expect(decider).to receive(:decide!).with(:type, :option).exactly(:once)
+      decider_klass = double('decider_klass')
+      allow(decider_klass).to receive(:new).with(kind_of(PerfectSched::Application::Base)).and_return(decider)
+      klass = PerfectSched::Application::Base
+      allow(klass).to receive(:decider).and_call_original
+      allow(klass).to receive(:decider=).with(decider_klass).and_call_original
+      klass.decider = decider_klass
+      klass.new(double('task'))
+    end
+    it 'calls decider.decide' do
+      expect(base.decide!(:type, :option)).to be_nil
+    end
+  end
+end

data/spec/application/decider_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe PerfectSched::Application::UndefinedDecisionError do
+  it { is_expected.to be_an_instance_of(PerfectSched::Application::UndefinedDecisionError) }
+  it { is_expected.to be_a(Exception) }
+end
+
+describe PerfectSched::Application::Decider do
+  let (:task){ double('task') }
+  let (:schedules){ double('schedules') }
+  let (:base){ double('base', schedules: schedules, task: task) }
+  let (:decider) { PerfectSched::Application::Decider.new(base) }
+  describe '#new' do
+    it 'returns a decider' do
+      expect(decider).to be_an_instance_of(PerfectSched::Application::Decider)
+      expect(decider.instance_variable_get(:@base)).to eq(base)
+    end
+  end
+
+  describe '#schedules' do
+    it 'returns @base.schedules' do
+      expect(decider.schedules).to eq(schedules)
+    end
+  end
+
+  describe '#task' do
+    let (:decider) do
+      base = double('base')
+      allow(base).to receive(:task).exactly(:once).and_return(task)
+      PerfectSched::Application::Decider.new(base)
+    end
+    it 'calls @base.task' do
+      expect(decider.task).to eq(task)
+    end
+  end
+
+  describe '#decide!' do
+    it 'calls the specified method' do
+      opts = double('opts')
+      ret = double('ret')
+      allow(decider).to receive(:foo).exactly(:once).with(opts).and_return(ret)
+      expect(decider.decide!(:foo, opts)).to eq(ret)
+    end
+    it 'raises UndefinedDecisionError on unknown method' do
+      expect{ decider.decide!(:foo, double) }.to raise_error(PerfectSched::Application::UndefinedDecisionError)
+    end
+  end
+end
+
+describe PerfectSched::Application::DefaultDecider do
+  subject { PerfectSched::Application::DefaultDecider.new(nil) }
+  it { is_expected.to be_a(PerfectSched::Application::Decider) }
+  it { is_expected.to be_an_instance_of(PerfectSched::Application::DefaultDecider) }
+end

data/spec/client_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Client do
+  let (:config){ {} }
+  let (:client){ Client.new(config) }
+  let (:ret){ double('ret') }
+  let (:backend){ double('backend') }
+  let (:options){ double('options') }
+  let (:task_token){ double('task_token') }
+  let (:key){ double('key') }
+  before do
+    allow(Backend).to receive(:new_backend) \
+      .with(kind_of(Client), config).and_return(backend)
+  end
+  describe '.new' do
+    subject { client }
+    it {
+      is_expected.to be_an_instance_of(Client) }
+  end
+  describe '#backend' do
+    subject { client.backend }
+    it { is_expected.to eq backend }
+  end
+  describe '#config' do
+    subject { client.config }
+    it { is_expected.to eq config }
+  end
+  describe '#init_database' do
+    subject { client.init_database(options) }
+    before { expect(backend).to receive(:init_database).with(options).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+  describe '#get_schedule_metadata' do
+    subject { client.get_schedule_metadata(key, options) }
+    before { expect(backend).to receive(:get_schedule_metadata).with(key, options).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+  describe '#delete' do
+    subject { client.delete(key, options) }
+    before { expect(backend).to receive(:delete).with(key, options).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+  describe '#modify' do
+    subject { client.modify(key, options) }
+    before { expect(backend).to receive(:modify).with(key, options).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+  describe '#list' do
+    let (:pr){ proc{} }
+    subject { client.list(key, &pr) }
+    before { expect(backend).to receive(:list).with(key){|*_, &b| expect(b).to eq pr; ret} }
+    it { is_expected.to eq ret }
+  end
+  describe '#acquire' do
+    let (:alive_time){ double('alive_time') }
+    let (:max_acquire){ double('max_acquire') }
+    subject { client.acquire(options) }
+    before { expect(backend).to receive(:acquire).with(alive_time, max_acquire, options).and_return(ret) }
+    context 'options are given' do
+      let (:options){ {alive_time: alive_time, max_acquire: max_acquire} }
+      it { is_expected.to eq ret }
+    end
+    context 'alive_time options is not given' do
+      let (:max_acquire){ 1 }
+      let (:options){ {} }
+      let (:config){ {alive_time: alive_time} }
+      it { is_expected.to eq ret }
+    end
+  end
+  describe '#release' do
+    let (:alive_time){ double('alive_time') }
+    subject { client.release(task_token, options) }
+    before { expect(backend).to receive(:release).with(task_token, alive_time, options).and_return(ret) }
+    context 'alive_time options is given' do
+      let (:options){ {alive_time: alive_time} }
+      it { is_expected.to eq ret }
+    end
+    context 'alive_time options is not given' do
+      let (:options){ {} }
+      let (:config){ {alive_time: alive_time} }
+      it { is_expected.to eq ret }
+    end
+  end
+  describe '#heartbeat' do
+    let (:alive_time){ double('alive_time') }
+    subject { client.heartbeat(task_token, options) }
+    before { expect(backend).to receive(:heartbeat).with(task_token, alive_time, options).and_return(ret) }
+    context 'alive_time options is given' do
+      let (:options){ {alive_time: alive_time} }
+      it { is_expected.to eq ret }
+    end
+    context 'alive_time options is not given' do
+      let (:options){ {} }
+      let (:config){ {alive_time: alive_time} }
+      it { is_expected.to eq ret }
+    end
+  end
+  describe '#retry' do
+    let (:retry_wait){ double('retry_wait') }
+    subject { client.retry(task_token, options) }
+    before { expect(backend).to receive(:heartbeat).with(task_token, retry_wait, options).and_return(ret) }
+    context 'retry_wait options is given' do
+      let (:options){ {retry_wait: retry_wait} }
+      it { is_expected.to eq ret }
+    end
+    context 'retry_wait options is not given' do
+      let (:options){ {} }
+      let (:config){ {retry_wait: retry_wait} }
+      it { is_expected.to eq ret }
+    end
+  end
+  describe '#finish' do
+    subject { client.finish(task_token, options) }
+    before { expect(backend).to receive(:finish).with(task_token, options).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+  describe '#close' do
+    subject { client.close }
+    before { expect(backend).to receive(:close).with(no_args).and_return(ret) }
+    it { is_expected.to eq ret }
+  end
+end